diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 5e7977fcc..da894d121 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -11,7 +11,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"] + python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"] steps: - uses: actions/checkout@v3 @@ -26,28 +26,24 @@ 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 + bash ./tools/build_talib_linux.sh - name: Build cython modules in-place run: | - python setup.py build_ext --inplace --include-dirs=$TA_INCLUDE_PATH --library-dirs=$TA_LIBRARY_PATH + python setup.py build_ext --inplace env: - TA_INCLUDE_PATH: ${{ github.workspace }}/dependencies/include - TA_LIBRARY_PATH: ${{ github.workspace }}/dependencies/lib + TA_INCLUDE_PATH: "ta-lib-install/include" + TA_LIBRARY_PATH: "ta-lib-install/lib" - 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 + LD_LIBRARY_PATH: "ta-lib-install/lib" diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml new file mode 100644 index 000000000..5d922c974 --- /dev/null +++ b/.github/workflows/wheels.yml @@ -0,0 +1,249 @@ + +name: Wheels +on: + push: + tags: + - "v*" + workflow_dispatch: + +env: + TALIB_C_VER: 0.6.4 + 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_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_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-13] + 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-14] + 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 06e4cde48..cae61b919 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,144 @@ +0.6.9 +===== + +- [NEW]: Upgrade to Cython 3.2.4 + +- [FIX]: Adding ACCBANDS, AVGDEV, IMI to get_func_groups() + +- [FIX]: Adding ACCBANDS, AVGDEV, IMI to docs pages + +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.2 + +- [NEW]: Build binary wheels for Windows, macOS, and Linux. + +0.6.4 +===== + +- [FIX]: Adding typed for ACCBANDS, AVGDEV, IMI, and stream_* functions + +- [FIX]: Fix for numpy 2.3.0, which removed the npy_1_7_deprecated_api + +0.6.3 +===== + +- [FIX]: Fix issue building against numpy2 + +0.6.2 +===== + +- [NEW]: Adding indicators ACCBANDS, AVGDEV, IMI + +0.6.1 +===== + +- [FIX]: Build properly against TA-Lib 0.6.2 and newer on Windows. + +0.6.0 +===== + +- [FIX]: Make sure this wrapper works with TA-Lib 0.6.1 and newer releases. + +0.5.5 +===== + +- [FIX]: Fix for numpy 2.3.0, which removed the npy_1_7_deprecated_api + +0.5.4 +===== + +- [FIX]: Fix lib name on windows. + +0.5.3 +===== + +- [BUG]: Make this release only support TA-Lib 0.4.0. + +0.5.2 +===== + +- [NEW]: Provide py typed information for C wrapper + +- [FIX]: Make sure this wrapper works with TA-Lib 0.6.1 + +0.5.1 +===== + +- [FIX]: include cython *.pxi files in the source tar.gz + +0.5.0 +===== + +- [NEW]: Upgrade to Numpy 2.0 + +0.4.38 +====== + +- [FIX]: Fix lib name on windows. + +0.4.37 +====== + +- [FIX]: Make sure to pin numpy<2 in the setup.py. + +0.4.36 +====== + +- [BUG]: Make this release only support TA-Lib 0.4.0 + +0.4.35 +====== + +- [FIX]: Make sure this wrapper works with TA-Lib 0.6.1 + +0.4.34 +===== + +- [FIX]: include cython *.pxi files in the source tar.gz + +0.4.33 +====== + +- [NEW]: Upgrade to Cython 3.0.11 + +- [FIX]: Fix import of ``pandas`` and ``polars`` to throw underlying import errors + +0.4.32 +====== + +- [FIX]: Make sure numpy<2 is in the requirements.txt + 0.4.31 ====== 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 16f2efc0e..44b36dba8 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -3,3 +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 7717a7fce..d86ef416a 100644 --- a/Makefile +++ b/Makefile @@ -1,10 +1,10 @@ .PHONY: build build: - python3 setup.py build_ext --inplace + python3 -m pip install --use-pep517 -e . install: - python3 setup.py install + python3 -m pip install --use-pep517 . talib/_func.pxi: tools/generate_func.py python3 tools/generate_func.py > talib/_func.pxi @@ -15,7 +15,10 @@ talib/_stream.pxi: tools/generate_stream.py generate: talib/_func.pxi talib/_stream.pxi cython: - cython --directive emit_code_comments=False talib/_ta_lib.pyx + cython talib/_ta_lib.pyx + +annotate: + cython -a talib/_ta_lib.pyx clean: rm -rf build talib/_ta_lib.so talib/*.pyc @@ -24,7 +27,7 @@ perf: python3 tools/perf_talib.py test: build - LD_LIBRARY_PATH=/usr/local/lib:${LD_LIBRARY_PATH} pytest + pytest tests/ sdist: - python3 setup.py sdist --formats=gztar,zip + python3 -m build --sdist diff --git a/README.md b/README.md index 824aa71b9..31ec2abe1 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,39 +23,53 @@ 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. -## Installation +## 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 +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) + +## 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): +```shell +conda install -c 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/hdr_dw.html) already installed. You should -probably follow their installation directions for your platform, but some +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 +directions](https://ta-lib.org/install/) for your platform, but some suggestions are included below for reference. > Some Conda Forge users have reported success installing the underlying TA-Lib C @@ -57,111 +77,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 -Download [ta-lib-0.4.0-msvc.zip](https://sourceforge.net/projects/ta-lib/files/ta-lib/0.4.0/ta-lib-0.4.0-msvc.zip/download) -and unzip to ``C:\ta-lib``. +For 64-bit Windows, the easiest way is to get the *executable installer*: -> This is a 32-bit binary release. If you want to use 64-bit Python, you will -> need to build a 64-bit version of the library. Some unofficial instructions -> for building on 64-bit Windows 10 or Windows 11, here for reference: -> -> 1. Download and Unzip ``ta-lib-0.4.0-msvc.zip`` -> 2. Move the Unzipped Folder ``ta-lib`` to ``C:\`` -> 3. Download and Install Visual Studio Community (2015 or later) -> * Remember to Select ``[Visual C++]`` Feature -> 4. Build TA-Lib Library -> * From Windows Start Menu, Start ``[VS2015 x64 Native Tools Command -> Prompt]`` -> * Move to ``C:\ta-lib\c\make\cdr\win32\msvc`` -> * Build the Library ``nmake`` +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). -You might also try these unofficial windows binary wheels for both 32-bit -and 64-bit: +Alternatively, if you prefer to get the libraries without installing, or +would like to use the 32-bit version: -https://github.com/cgohlke/talib-build/ +* 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) -##### Linux +#### Linux Download -[ta-lib-0.4.0-src.tar.gz](https://sourceforge.net/projects/ta-lib/files/ta-lib/0.4.0/ta-lib-0.4.0-src.tar.gz/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) and: -``` -$ tar -xzf ta-lib-0.4.0-src.tar.gz -$ cd ta-lib/ -$ ./configure --prefix=/usr -$ make -$ sudo make install +```shell +tar -xzf ta-lib-0.6.4-src.tar.gz +cd ta-lib-0.6.4/ +./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 +212,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 +220,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 +240,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 +278,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 +289,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,8 +312,16 @@ 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: + +```shell +sudo fallocate -l 1G /swapfile +sudo chmod 600 /swapfile +sudo mkswap /swapfile +sudo swapon /swapfile +``` --- @@ -279,7 +329,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" ^ @@ -291,26 +341,60 @@ 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 -to copy a newer version of config.guess into the underyling TA-Lib C library +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: +```shell +./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' ``` -$ ./configure + +Then, perhaps you can use the `--hidden-import` argument to fix this: + +```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 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 +work. + ## Function API Similar to TA-Lib, the Function API provides a lightweight wrapper of the @@ -319,10 +403,10 @@ 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. +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: @@ -353,7 +437,7 @@ Calculating momentum of the close prices, with a time period of 5: output = talib.MOM(close, timeperiod=5) ``` -##### NaN's +### 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: @@ -464,10 +548,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 @@ -484,7 +568,7 @@ for group, names in talib.get_function_groups().items(): print(f" {name}") ``` -### Indicator Groups +### Indicator Groups 🏷️ * Overlap Studies * Momentum Indicators @@ -494,8 +578,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 @@ -515,8 +600,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 @@ -549,15 +635,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 @@ -565,23 +653,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 @@ -645,8 +736,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_groups/cycle_indicators.md b/docs/func_groups/cycle_indicators.md index 7b267b73e..db5761f26 100644 --- a/docs/func_groups/cycle_indicators.md +++ b/docs/func_groups/cycle_indicators.md @@ -2,31 +2,31 @@ ### HT_DCPERIOD - Hilbert Transform - Dominant Cycle Period NOTE: The ``HT_DCPERIOD`` function has an unstable period. ```python -real = HT_DCPERIOD(close) +real = HT_DCPERIOD(real) ``` ### HT_DCPHASE - Hilbert Transform - Dominant Cycle Phase NOTE: The ``HT_DCPHASE`` function has an unstable period. ```python -real = HT_DCPHASE(close) +real = HT_DCPHASE(real) ``` ### HT_PHASOR - Hilbert Transform - Phasor Components NOTE: The ``HT_PHASOR`` function has an unstable period. ```python -inphase, quadrature = HT_PHASOR(close) +inphase, quadrature = HT_PHASOR(real) ``` ### HT_SINE - Hilbert Transform - SineWave NOTE: The ``HT_SINE`` function has an unstable period. ```python -sine, leadsine = HT_SINE(close) +sine, leadsine = HT_SINE(real) ``` ### HT_TRENDMODE - Hilbert Transform - Trend vs Cycle Mode NOTE: The ``HT_TRENDMODE`` function has an unstable period. ```python -integer = HT_TRENDMODE(close) +integer = HT_TRENDMODE(real) ``` diff --git a/docs/func_groups/math_operators.md b/docs/func_groups/math_operators.md index 0d72dbe8a..7a48fde22 100644 --- a/docs/func_groups/math_operators.md +++ b/docs/func_groups/math_operators.md @@ -1,60 +1,60 @@ # Math Operator Functions ### ADD - Vector Arithmetic Add ```python -real = ADD(high, low) +real = ADD(real0, real1) ``` ### DIV - Vector Arithmetic Div ```python -real = DIV(high, low) +real = DIV(real0, real1) ``` ### MAX - Highest value over a specified period ```python -real = MAX(close, timeperiod=30) +real = MAX(real, timeperiod=30) ``` ### MAXINDEX - Index of highest value over a specified period ```python -integer = MAXINDEX(close, timeperiod=30) +integer = MAXINDEX(real, timeperiod=30) ``` ### MIN - Lowest value over a specified period ```python -real = MIN(close, timeperiod=30) +real = MIN(real, timeperiod=30) ``` ### MININDEX - Index of lowest value over a specified period ```python -integer = MININDEX(close, timeperiod=30) +integer = MININDEX(real, timeperiod=30) ``` ### MINMAX - Lowest and highest values over a specified period ```python -min, max = MINMAX(close, timeperiod=30) +min, max = MINMAX(real, timeperiod=30) ``` ### MINMAXINDEX - Indexes of lowest and highest values over a specified period ```python -minidx, maxidx = MINMAXINDEX(close, timeperiod=30) +minidx, maxidx = MINMAXINDEX(real, timeperiod=30) ``` ### MULT - Vector Arithmetic Mult ```python -real = MULT(high, low) +real = MULT(real0, real1) ``` ### SUB - Vector Arithmetic Subtraction ```python -real = SUB(high, low) +real = SUB(real0, real1) ``` ### SUM - Summation ```python -real = SUM(close, timeperiod=30) +real = SUM(real, timeperiod=30) ``` [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/func_groups/math_transform.md b/docs/func_groups/math_transform.md index 696051ab6..749f8d034 100644 --- a/docs/func_groups/math_transform.md +++ b/docs/func_groups/math_transform.md @@ -1,80 +1,80 @@ # Math Transform Functions ### ACOS - Vector Trigonometric ACos ```python -real = ACOS(close) +real = ACOS(real) ``` ### ASIN - Vector Trigonometric ASin ```python -real = ASIN(close) +real = ASIN(real) ``` ### ATAN - Vector Trigonometric ATan ```python -real = ATAN(close) +real = ATAN(real) ``` ### CEIL - Vector Ceil ```python -real = CEIL(close) +real = CEIL(real) ``` ### COS - Vector Trigonometric Cos ```python -real = COS(close) +real = COS(real) ``` ### COSH - Vector Trigonometric Cosh ```python -real = COSH(close) +real = COSH(real) ``` ### EXP - Vector Arithmetic Exp ```python -real = EXP(close) +real = EXP(real) ``` ### FLOOR - Vector Floor ```python -real = FLOOR(close) +real = FLOOR(real) ``` ### LN - Vector Log Natural ```python -real = LN(close) +real = LN(real) ``` ### LOG10 - Vector Log10 ```python -real = LOG10(close) +real = LOG10(real) ``` ### SIN - Vector Trigonometric Sin ```python -real = SIN(close) +real = SIN(real) ``` ### SINH - Vector Trigonometric Sinh ```python -real = SINH(close) +real = SINH(real) ``` ### SQRT - Vector Square Root ```python -real = SQRT(close) +real = SQRT(real) ``` ### TAN - Vector Trigonometric Tan ```python -real = TAN(close) +real = TAN(real) ``` ### TANH - Vector Trigonometric Tanh ```python -real = TANH(close) +real = TANH(real) ``` [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/func_groups/momentum_indicators.md b/docs/func_groups/momentum_indicators.md index ba7e5cd54..c859d89b2 100644 --- a/docs/func_groups/momentum_indicators.md +++ b/docs/func_groups/momentum_indicators.md @@ -13,7 +13,7 @@ real = ADXR(high, low, close, timeperiod=14) ### APO - Absolute Price Oscillator ```python -real = APO(close, fastperiod=12, slowperiod=26, matype=0) +real = APO(real, fastperiod=12, slowperiod=26, matype=0) ``` ### AROON - Aroon @@ -39,7 +39,7 @@ real = CCI(high, low, close, timeperiod=14) ### CMO - Chande Momentum Oscillator NOTE: The ``CMO`` function has an unstable period. ```python -real = CMO(close, timeperiod=14) +real = CMO(real, timeperiod=14) ``` ### DX - Directional Movement Index @@ -48,19 +48,25 @@ 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(close, fastperiod=12, slowperiod=26, signalperiod=9) +macd, macdsignal, macdhist = MACD(real, fastperiod=12, slowperiod=26, signalperiod=9) ``` ### MACDEXT - MACD with controllable MA type ```python -macd, macdsignal, macdhist = MACDEXT(close, fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0) +macd, macdsignal, macdhist = MACDEXT(real, fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0) ``` ### MACDFIX - Moving Average Convergence/Divergence Fix 12/26 ```python -macd, macdsignal, macdhist = MACDFIX(close, signalperiod=9) +macd, macdsignal, macdhist = MACDFIX(real, signalperiod=9) ``` ### MFI - Money Flow Index @@ -83,7 +89,7 @@ real = MINUS_DM(high, low, timeperiod=14) ### MOM - Momentum ```python -real = MOM(close, timeperiod=10) +real = MOM(real, timeperiod=10) ``` ### PLUS_DI - Plus Directional Indicator @@ -100,33 +106,33 @@ real = PLUS_DM(high, low, timeperiod=14) ### PPO - Percentage Price Oscillator ```python -real = PPO(close, fastperiod=12, slowperiod=26, matype=0) +real = PPO(real, fastperiod=12, slowperiod=26, matype=0) ``` ### ROC - Rate of change : ((price/prevPrice)-1)*100 ```python -real = ROC(close, timeperiod=10) +real = ROC(real, timeperiod=10) ``` ### ROCP - Rate of change Percentage: (price-prevPrice)/prevPrice ```python -real = ROCP(close, timeperiod=10) +real = ROCP(real, timeperiod=10) ``` ### ROCR - Rate of change ratio: (price/prevPrice) ```python -real = ROCR(close, timeperiod=10) +real = ROCR(real, timeperiod=10) ``` ### ROCR100 - Rate of change ratio 100 scale: (price/prevPrice)*100 ```python -real = ROCR100(close, timeperiod=10) +real = ROCR100(real, timeperiod=10) ``` ### RSI - Relative Strength Index NOTE: The ``RSI`` function has an unstable period. ```python -real = RSI(close, timeperiod=14) +real = RSI(real, timeperiod=14) ``` ### STOCH - Stochastic @@ -142,12 +148,12 @@ fastk, fastd = STOCHF(high, low, close, fastk_period=5, fastd_period=3, fastd_ma ### STOCHRSI - Stochastic Relative Strength Index NOTE: The ``STOCHRSI`` function has an unstable period. ```python -fastk, fastd = STOCHRSI(close, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0) +fastk, fastd = STOCHRSI(real, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0) ``` ### TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA ```python -real = TRIX(close, timeperiod=30) +real = TRIX(real, timeperiod=30) ``` ### ULTOSC - Ultimate Oscillator @@ -163,4 +169,4 @@ real = WILLR(high, low, close, timeperiod=14) [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/func_groups/overlap_studies.md b/docs/func_groups/overlap_studies.md index 4144251b1..8c6305223 100644 --- a/docs/func_groups/overlap_studies.md +++ b/docs/func_groups/overlap_studies.md @@ -1,51 +1,56 @@ # Overlap Studies Functions +### ACCBANDS - Acceleration Bands +```python +upperband, middleband, lowerband = ACCBANDS(high, low, close, timeperiod=20) +``` + ### BBANDS - Bollinger Bands ```python -upperband, middleband, lowerband = BBANDS(close, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0) +upperband, middleband, lowerband = BBANDS(real, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0) ``` ### DEMA - Double Exponential Moving Average ```python -real = DEMA(close, timeperiod=30) +real = DEMA(real, timeperiod=30) ``` ### EMA - Exponential Moving Average NOTE: The ``EMA`` function has an unstable period. ```python -real = EMA(close, timeperiod=30) +real = EMA(real, timeperiod=30) ``` ### HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline NOTE: The ``HT_TRENDLINE`` function has an unstable period. ```python -real = HT_TRENDLINE(close) +real = HT_TRENDLINE(real) ``` ### KAMA - Kaufman Adaptive Moving Average NOTE: The ``KAMA`` function has an unstable period. ```python -real = KAMA(close, timeperiod=30) +real = KAMA(real, timeperiod=30) ``` ### MA - Moving average ```python -real = MA(close, timeperiod=30, matype=0) +real = MA(real, timeperiod=30, matype=0) ``` ### MAMA - MESA Adaptive Moving Average NOTE: The ``MAMA`` function has an unstable period. ```python -mama, fama = MAMA(close, fastlimit=0, slowlimit=0) +mama, fama = MAMA(real, fastlimit=0, slowlimit=0) ``` ### MAVP - Moving average with variable period ```python -real = MAVP(close, periods, minperiod=2, maxperiod=30, matype=0) +real = MAVP(real, periods, minperiod=2, maxperiod=30, matype=0) ``` ### MIDPOINT - MidPoint over period ```python -real = MIDPOINT(close, timeperiod=14) +real = MIDPOINT(real, timeperiod=14) ``` ### MIDPRICE - Midpoint Price over period @@ -65,31 +70,30 @@ real = SAREXT(high, low, startvalue=0, offsetonreverse=0, accelerationinitlong=0 ### SMA - Simple Moving Average ```python -real = SMA(close, timeperiod=30) +real = SMA(real, timeperiod=30) ``` ### T3 - Triple Exponential Moving Average (T3) NOTE: The ``T3`` function has an unstable period. ```python -real = T3(close, timeperiod=5, vfactor=0) +real = T3(real, timeperiod=5, vfactor=0) ``` ### TEMA - Triple Exponential Moving Average ```python -real = TEMA(close, timeperiod=30) +real = TEMA(real, timeperiod=30) ``` ### TRIMA - Triangular Moving Average ```python -real = TRIMA(close, timeperiod=30) +real = TRIMA(real, timeperiod=30) ``` ### WMA - Weighted Moving Average ```python -real = WMA(close, timeperiod=30) +real = WMA(real, timeperiod=30) ``` - [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/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/func_groups/statistic_functions.md b/docs/func_groups/statistic_functions.md index b068137d0..db629952c 100644 --- a/docs/func_groups/statistic_functions.md +++ b/docs/func_groups/statistic_functions.md @@ -1,50 +1,50 @@ # Statistic Functions ### BETA - Beta ```python -real = BETA(high, low, timeperiod=5) +real = BETA(real0, real1, timeperiod=5) ``` ### CORREL - Pearson's Correlation Coefficient (r) ```python -real = CORREL(high, low, timeperiod=30) +real = CORREL(real0, real1, timeperiod=30) ``` ### LINEARREG - Linear Regression ```python -real = LINEARREG(close, timeperiod=14) +real = LINEARREG(real, timeperiod=14) ``` ### LINEARREG_ANGLE - Linear Regression Angle ```python -real = LINEARREG_ANGLE(close, timeperiod=14) +real = LINEARREG_ANGLE(real, timeperiod=14) ``` ### LINEARREG_INTERCEPT - Linear Regression Intercept ```python -real = LINEARREG_INTERCEPT(close, timeperiod=14) +real = LINEARREG_INTERCEPT(real, timeperiod=14) ``` ### LINEARREG_SLOPE - Linear Regression Slope ```python -real = LINEARREG_SLOPE(close, timeperiod=14) +real = LINEARREG_SLOPE(real, timeperiod=14) ``` ### STDDEV - Standard Deviation ```python -real = STDDEV(close, timeperiod=5, nbdev=1) +real = STDDEV(real, timeperiod=5, nbdev=1) ``` ### TSF - Time Series Forecast ```python -real = TSF(close, timeperiod=14) +real = TSF(real, timeperiod=14) ``` ### VAR - Variance ```python -real = VAR(close, timeperiod=5, nbdev=1) +real = VAR(real, timeperiod=5, nbdev=1) ``` [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/pyproject.toml b/pyproject.toml index fbb3e6717..6083626b6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,3 +1,44 @@ [build-system] -requires = ["setuptools >= 51.0.0", "wheel", "numpy<2.0.0"] -build-backend = "setuptools.build_meta:__legacy__" +requires = ["setuptools", "wheel", "Cython", "numpy"] +build-backend = "setuptools.build_meta" + +[project] +name = "TA-Lib" +version = "0.6.9" +description = "Python wrapper for TA-Lib" +readme = "README.md" +license-files = ["LICENSE"] +authors = [ + {name = "John Benediktsson", email = "mrjbq7@gmail.com"} +] +urls = {homepage = "http://github.com/ta-lib/ta-lib-python", download = "https://github.com/ta-lib/ta-lib-python/releases"} +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Operating System :: Unix", + "Operating System :: POSIX", + "Operating System :: MacOS :: MacOS X", + "Operating System :: Microsoft :: Windows", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Programming Language :: Cython", + "Topic :: Office/Business :: Financial", + "Topic :: Scientific/Engineering :: Mathematics", + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "Intended Audience :: Financial and Insurance Industry", +] +dependencies = [ + "build", + "numpy", +] +requires-python = '>=3.9' + +[tool.setuptools] +packages = ["talib"] +package-data = {"talib" = ["_ta_lib.pyi", "py.typed"]} diff --git a/requirements.txt b/requirements.txt index 6d39d4295..70bf4e3ba 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1,2 @@ -numpy<2.0.0 +numpy Cython diff --git a/requirements_dev.txt b/requirements_dev.txt index 8dbce1cd6..3a6c0a909 100644 --- a/requirements_dev.txt +++ b/requirements_dev.txt @@ -2,3 +2,5 @@ beautifulsoup4 mistune Pygments +build +cython diff --git a/setup.py b/setup.py index 5ccd919ad..874983353 100644 --- a/setup.py +++ b/setup.py @@ -5,23 +5,14 @@ import os.path import warnings -try: - from setuptools import setup, Extension - from setuptools.dist import Distribution - requires = { - "install_requires": ["numpy"], - "setup_requires": ["numpy"] - } -except ImportError: - from distutils.core import setup - from distutils.dist import Distribution - from distutils.extension import Extension - requires = {"requires": ["numpy"]} +from setuptools import setup, Extension -lib_talib_name = 'ta_lib' # the underlying C library's name +import numpy platform_supported = False +lib_talib_name = 'ta-lib' # the name as of TA-Lib 0.6.1 + if any(s in sys.platform for s in ['darwin', 'linux', 'bsd', 'sunos']): platform_supported = True include_dirs = [ @@ -45,9 +36,17 @@ elif sys.platform == "win32": platform_supported = True - lib_talib_name = 'ta_libc_cdr' - include_dirs = [r"c:\ta-lib\c\include"] - library_dirs = [r"c:\ta-lib\c\lib"] + lib_talib_name = 'ta-lib-static' + include_dirs = [ + r"c:\ta-lib\c\include", + r"c:\Program Files\TA-Lib\include", + r"c:\Program Files (x86)\TA-Lib\include", + ] + library_dirs = [ + r"c:\ta-lib\c\lib", + r"c:\Program Files\TA-Lib\lib", + r"c:\Program Files (x86)\TA-Lib\lib", + ] if 'TA_INCLUDE_PATH' in os.environ: include_dirs = os.environ['TA_INCLUDE_PATH'].split(os.pathsep) @@ -58,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) @@ -74,57 +67,30 @@ else: warnings.warn('Cannot find ta-lib library, installation may fail.') +# Get the Cython build_ext or fall back to setuptools build_ext +try: + from Cython.Distutils import build_ext + has_cython = True +except ImportError: + from setuptools.command.build_ext import build_ext + has_cython = False -class LazyBuildExtCommandClass(dict): +class NumpyBuildExt(build_ext): """ - Lazy command class that defers operations requiring Cython and numpy until - they've actually been downloaded and installed by setup_requires. + Custom build_ext command that adds numpy's include_dir to extensions. """ - def __contains__(self, key): - return (key == 'build_ext' or - super(LazyBuildExtCommandClass, self).__contains__(key)) - - def __setitem__(self, key, value): - if key == 'build_ext': - raise AssertionError("build_ext overridden!") - super(LazyBuildExtCommandClass, self).__setitem__(key, value) - - def __getitem__(self, key): - global include_dirs - if key != 'build_ext': - return super(LazyBuildExtCommandClass, self).__getitem__(key) + def build_extensions(self): + """ + Add numpy's include directory to Extension includes. + """ + numpy_incl = numpy.get_include() + for ext in self.extensions: + ext.include_dirs.append(numpy_incl) - import numpy - if has_cython: - org_build_ext = cython_build_ext - else: - from setuptools.command.build_ext import build_ext as org_build_ext + super().build_extensions() - # Cython_build_ext isn't a new-style class in Py2. - class build_ext(org_build_ext, object): - """ - Custom build_ext command that lazily adds numpy's include_dir to - extensions. - """ - - def build_extensions(self): - """ - Lazily append numpy's include directory to Extension includes. - This is done here rather than at module scope because setup.py - may be run before numpy has been installed, in which case - importing numpy and calling `numpy.get_include()` will fail. - """ - numpy_incl = numpy.get_include() - for ext in self.extensions: - ext.include_dirs.append(numpy_incl) - - super(build_ext, self).build_extensions() - - return build_ext - - -cmdclass = LazyBuildExtCommandClass() +cmdclass = {'build_ext': NumpyBuildExt} ext_modules = [ Extension( @@ -136,51 +102,7 @@ def build_extensions(self): runtime_library_dirs=[] if sys.platform == 'win32' else library_dirs) ] -from os import path -this_directory = path.abspath(path.dirname(__file__)) -with open(path.join(this_directory, 'README.md'), encoding='utf-8') as f: - long_description = f.read() - setup( - name='TA-Lib', - version='0.4.31', - description='Python wrapper for TA-Lib', - long_description=long_description, - long_description_content_type='text/markdown', - author='John Benediktsson', - author_email='mrjbq7@gmail.com', - url='http://github.com/ta-lib/ta-lib-python', - download_url='https://github.com/ta-lib/ta-lib-python/releases', - license='BSD', - classifiers=[ - "License :: OSI Approved :: BSD License", - "Development Status :: 5 - Production/Stable", - "Operating System :: Unix", - "Operating System :: POSIX", - "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", - "Programming Language :: Python :: 3.12", - "Programming Language :: Cython", - "Topic :: Office/Business :: Financial", - "Topic :: Scientific/Engineering :: Mathematics", - "Intended Audience :: Developers", - "Intended Audience :: Science/Research", - "Intended Audience :: Financial and Insurance Industry", - ], - packages=['talib'], ext_modules=ext_modules, cmdclass=cmdclass, - **requires) +) diff --git a/talib/__init__.py b/talib/__init__.py index d729af614..c2df327d1 100644 --- a/talib/__init__.py +++ b/talib/__init__.py @@ -7,7 +7,15 @@ # polars.Series input try: from polars import Series as _pl_Series -except ImportError: +except ImportError as import_error: + try: + if not isinstance(import_error, ModuleNotFoundError) or import_error.name != 'polars': + # Propagate the error when the module exists but failed to be imported. + raise import_error + # `ModuleNotFoundError` was introduced in Python 3.6. + except NameError: + pass + # polars not available, nothing to wrap _pl_Series = None @@ -15,7 +23,15 @@ # pandas.Series input try: from pandas import Series as _pd_Series -except ImportError: +except ImportError as import_error: + try: + if not isinstance(import_error, ModuleNotFoundError) or import_error.name != 'pandas': + # Propagate the error when the module exists but failed to be imported. + raise import_error + # `ModuleNotFoundError` was introduced in Python 3.6. + except NameError: + pass + # pandas not available, nothing to wrap _pd_Series = None @@ -116,7 +132,7 @@ def wrapper(*args, **kwds): setattr(stream, func_name, wrapped_func) globals()[stream_func_name] = wrapped_func -__version__ = '0.4.31' +__version__ = '0.6.9' # 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 @@ -176,6 +192,7 @@ def wrapper(*args, **kwds): 'CCI', 'CMO', 'DX', + 'IMI', 'MACD', 'MACDEXT', 'MACDFIX', @@ -199,6 +216,7 @@ def wrapper(*args, **kwds): 'WILLR', ], 'Overlap Studies': [ + 'ACCBANDS', 'BBANDS', 'DEMA', 'EMA', @@ -281,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 cb09e3c49..6989ab80d 100644 --- a/talib/_abstract.pxi +++ b/talib/_abstract.pxi @@ -15,6 +15,7 @@ cimport numpy as np cimport _ta_lib as lib # NOTE: _ta_check_success, MA_Type is defined in _common.pxi +np.import_array() # Initialize the NumPy C API # lookup for TALIB input parameters which don't define expected price series inputs __INPUT_PRICE_SERIES_DEFAULTS = {'price': 'close', @@ -33,7 +34,15 @@ try: __ARRAY_TYPES.append(pandas.Series) __PANDAS_DATAFRAME = pandas.DataFrame __PANDAS_SERIES = pandas.Series -except ImportError: +except ImportError as import_error: + try: + if not isinstance(import_error, ModuleNotFoundError) or import_error.name != 'pandas': + # Propagate the error when the module exists but failed to be imported. + raise import_error + # `ModuleNotFoundError` was introduced in Python 3.6. + except NameError: + pass + __PANDAS_DATAFRAME = None __PANDAS_SERIES = None @@ -44,7 +53,15 @@ try: __ARRAY_TYPES.append(polars.Series) __POLARS_DATAFRAME = polars.DataFrame __POLARS_SERIES = polars.Series -except ImportError: +except ImportError as import_error: + try: + if not isinstance(import_error, ModuleNotFoundError) or import_error.name != 'polars': + # Propagate the error when the module exists but failed to be imported. + raise import_error + # `ModuleNotFoundError` was introduced in Python 3.6. + except NameError: + pass + __POLARS_DATAFRAME = None __POLARS_SERIES = None @@ -88,7 +105,7 @@ class Function(object): - set_function_args([input_arrays,] [param_args_andor_kwargs]) Documentation for param_args_andor_kwargs can be seen by printing the - Function instance or programatically via the info, input_names and + Function instance or programmatically via the info, input_names and parameters properties. ----- result-returning functions ----- @@ -679,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/_func.pxi b/talib/_func.pxi index 5d60d7dd3..c4555a42c 100644 --- a/talib/_func.pxi +++ b/talib/_func.pxi @@ -22,7 +22,7 @@ cdef np.ndarray check_array(np.ndarray real): raise Exception("input array type is not double") if real.ndim != 1: raise Exception("input array has wrong dimensions") - if not (PyArray_FLAGS(real) & np.NPY_C_CONTIGUOUS): + if not (PyArray_FLAGS(real) & np.NPY_ARRAY_C_CONTIGUOUS): real = PyArray_GETCONTIGUOUS(real) return real @@ -122,7 +122,7 @@ cdef np.ndarray make_double_array(np.npy_intp length, int lookback): cdef: np.ndarray outreal double* outreal_data - outreal = PyArray_EMPTY(1, &length, np.NPY_DOUBLE, np.NPY_DEFAULT) + outreal = PyArray_EMPTY(1, &length, np.NPY_DOUBLE, np.NPY_ARRAY_DEFAULT) outreal_data = outreal.data for i from 0 <= i < min(lookback, length): outreal_data[i] = NaN @@ -132,13 +132,52 @@ cdef np.ndarray make_int_array(np.npy_intp length, int lookback): cdef: np.ndarray outinteger int* outinteger_data - outinteger = PyArray_EMPTY(1, &length, np.NPY_INT32, np.NPY_DEFAULT) + outinteger = PyArray_EMPTY(1, &length, np.NPY_INT32, np.NPY_ARRAY_DEFAULT) outinteger_data = outinteger.data for i from 0 <= i < min(lookback, length): outinteger_data[i] = 0 return outinteger +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def ACCBANDS( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ ACCBANDS(high, low, close[, timeperiod=?]) + + Acceleration Bands (Overlap Studies) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 20 + Outputs: + upperband + middleband + lowerband + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outrealupperband + np.ndarray outrealmiddleband + np.ndarray outreallowerband + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length3(high, low, close) + begidx = check_begidx3(length, (high.data), (low.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_ACCBANDS_Lookback( timeperiod ) + outrealupperband = make_double_array(length, lookback) + outrealmiddleband = make_double_array(length, lookback) + outreallowerband = make_double_array(length, lookback) + retCode = lib.TA_ACCBANDS( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outrealupperband.data)+lookback , (outrealmiddleband.data)+lookback , (outreallowerband.data)+lookback ) + _ta_check_success("TA_ACCBANDS", retCode) + return outrealupperband , outrealmiddleband , outreallowerband + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ACOS( np.ndarray real not None ): @@ -555,6 +594,37 @@ def AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.ndarray l _ta_check_success("TA_AVGPRICE", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def AVGDEV( np.ndarray real not None , int timeperiod=-2**31 ): + """ AVGDEV(real[, timeperiod=?]) + + Average Deviation (Price Transform) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_AVGDEV_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_AVGDEV( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_AVGDEV", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def BBANDS( np.ndarray real not None , int timeperiod=-2**31 , double nbdevup=-4e37 , double nbdevdn=-4e37 , int matype=0 ): @@ -3174,6 +3244,38 @@ def HT_TRENDMODE( np.ndarray real not None ): _ta_check_success("TA_HT_TRENDMODE", retCode) return outinteger +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def IMI( np.ndarray open not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ IMI(open, close[, timeperiod=?]) + + Intraday Momentum Index (Momentum Indicators) + + Inputs: + prices: ['open', 'close'] + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + open = check_array(open) + close = check_array(close) + length = check_length2(open, close) + begidx = check_begidx2(length, (open.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_IMI_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_IMI( 0 , endidx , (open.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_IMI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def KAMA( np.ndarray real not None , int timeperiod=-2**31 ): @@ -5219,4 +5321,4 @@ def WMA( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_WMA", retCode) return outreal -__TA_FUNCTION_NAMES__ = ["ACOS","AD","ADD","ADOSC","ADX","ADXR","APO","AROON","AROONOSC","ASIN","ATAN","ATR","AVGPRICE","BBANDS","BETA","BOP","CCI","CDL2CROWS","CDL3BLACKCROWS","CDL3INSIDE","CDL3LINESTRIKE","CDL3OUTSIDE","CDL3STARSINSOUTH","CDL3WHITESOLDIERS","CDLABANDONEDBABY","CDLADVANCEBLOCK","CDLBELTHOLD","CDLBREAKAWAY","CDLCLOSINGMARUBOZU","CDLCONCEALBABYSWALL","CDLCOUNTERATTACK","CDLDARKCLOUDCOVER","CDLDOJI","CDLDOJISTAR","CDLDRAGONFLYDOJI","CDLENGULFING","CDLEVENINGDOJISTAR","CDLEVENINGSTAR","CDLGAPSIDESIDEWHITE","CDLGRAVESTONEDOJI","CDLHAMMER","CDLHANGINGMAN","CDLHARAMI","CDLHARAMICROSS","CDLHIGHWAVE","CDLHIKKAKE","CDLHIKKAKEMOD","CDLHOMINGPIGEON","CDLIDENTICAL3CROWS","CDLINNECK","CDLINVERTEDHAMMER","CDLKICKING","CDLKICKINGBYLENGTH","CDLLADDERBOTTOM","CDLLONGLEGGEDDOJI","CDLLONGLINE","CDLMARUBOZU","CDLMATCHINGLOW","CDLMATHOLD","CDLMORNINGDOJISTAR","CDLMORNINGSTAR","CDLONNECK","CDLPIERCING","CDLRICKSHAWMAN","CDLRISEFALL3METHODS","CDLSEPARATINGLINES","CDLSHOOTINGSTAR","CDLSHORTLINE","CDLSPINNINGTOP","CDLSTALLEDPATTERN","CDLSTICKSANDWICH","CDLTAKURI","CDLTASUKIGAP","CDLTHRUSTING","CDLTRISTAR","CDLUNIQUE3RIVER","CDLUPSIDEGAP2CROWS","CDLXSIDEGAP3METHODS","CEIL","CMO","CORREL","COS","COSH","DEMA","DIV","DX","EMA","EXP","FLOOR","HT_DCPERIOD","HT_DCPHASE","HT_PHASOR","HT_SINE","HT_TRENDLINE","HT_TRENDMODE","KAMA","LINEARREG","LINEARREG_ANGLE","LINEARREG_INTERCEPT","LINEARREG_SLOPE","LN","LOG10","MA","MACD","MACDEXT","MACDFIX","MAMA","MAVP","MAX","MAXINDEX","MEDPRICE","MFI","MIDPOINT","MIDPRICE","MIN","MININDEX","MINMAX","MINMAXINDEX","MINUS_DI","MINUS_DM","MOM","MULT","NATR","OBV","PLUS_DI","PLUS_DM","PPO","ROC","ROCP","ROCR","ROCR100","RSI","SAR","SAREXT","SIN","SINH","SMA","SQRT","STDDEV","STOCH","STOCHF","STOCHRSI","SUB","SUM","T3","TAN","TANH","TEMA","TRANGE","TRIMA","TRIX","TSF","TYPPRICE","ULTOSC","VAR","WCLPRICE","WILLR","WMA"] +__TA_FUNCTION_NAMES__ = ["ACCBANDS","ACOS","AD","ADD","ADOSC","ADX","ADXR","APO","AROON","AROONOSC","ASIN","ATAN","ATR","AVGPRICE","AVGDEV","BBANDS","BETA","BOP","CCI","CDL2CROWS","CDL3BLACKCROWS","CDL3INSIDE","CDL3LINESTRIKE","CDL3OUTSIDE","CDL3STARSINSOUTH","CDL3WHITESOLDIERS","CDLABANDONEDBABY","CDLADVANCEBLOCK","CDLBELTHOLD","CDLBREAKAWAY","CDLCLOSINGMARUBOZU","CDLCONCEALBABYSWALL","CDLCOUNTERATTACK","CDLDARKCLOUDCOVER","CDLDOJI","CDLDOJISTAR","CDLDRAGONFLYDOJI","CDLENGULFING","CDLEVENINGDOJISTAR","CDLEVENINGSTAR","CDLGAPSIDESIDEWHITE","CDLGRAVESTONEDOJI","CDLHAMMER","CDLHANGINGMAN","CDLHARAMI","CDLHARAMICROSS","CDLHIGHWAVE","CDLHIKKAKE","CDLHIKKAKEMOD","CDLHOMINGPIGEON","CDLIDENTICAL3CROWS","CDLINNECK","CDLINVERTEDHAMMER","CDLKICKING","CDLKICKINGBYLENGTH","CDLLADDERBOTTOM","CDLLONGLEGGEDDOJI","CDLLONGLINE","CDLMARUBOZU","CDLMATCHINGLOW","CDLMATHOLD","CDLMORNINGDOJISTAR","CDLMORNINGSTAR","CDLONNECK","CDLPIERCING","CDLRICKSHAWMAN","CDLRISEFALL3METHODS","CDLSEPARATINGLINES","CDLSHOOTINGSTAR","CDLSHORTLINE","CDLSPINNINGTOP","CDLSTALLEDPATTERN","CDLSTICKSANDWICH","CDLTAKURI","CDLTASUKIGAP","CDLTHRUSTING","CDLTRISTAR","CDLUNIQUE3RIVER","CDLUPSIDEGAP2CROWS","CDLXSIDEGAP3METHODS","CEIL","CMO","CORREL","COS","COSH","DEMA","DIV","DX","EMA","EXP","FLOOR","HT_DCPERIOD","HT_DCPHASE","HT_PHASOR","HT_SINE","HT_TRENDLINE","HT_TRENDMODE","IMI","KAMA","LINEARREG","LINEARREG_ANGLE","LINEARREG_INTERCEPT","LINEARREG_SLOPE","LN","LOG10","MA","MACD","MACDEXT","MACDFIX","MAMA","MAVP","MAX","MAXINDEX","MEDPRICE","MFI","MIDPOINT","MIDPRICE","MIN","MININDEX","MINMAX","MINMAXINDEX","MINUS_DI","MINUS_DM","MOM","MULT","NATR","OBV","PLUS_DI","PLUS_DM","PPO","ROC","ROCP","ROCR","ROCR100","RSI","SAR","SAREXT","SIN","SINH","SMA","SQRT","STDDEV","STOCH","STOCHF","STOCHRSI","SUB","SUM","T3","TAN","TANH","TEMA","TRANGE","TRIMA","TRIX","TSF","TYPPRICE","ULTOSC","VAR","WCLPRICE","WILLR","WMA"] diff --git a/talib/_stream.pxi b/talib/_stream.pxi index 66a2b359c..b1575b2cc 100644 --- a/talib/_stream.pxi +++ b/talib/_stream.pxi @@ -3,8 +3,49 @@ from cython import boundscheck, wraparound cimport _ta_lib as lib from _ta_lib cimport TA_RetCode # NOTE: _ta_check_success, NaN are defined in common.pxi -# NumPy C API is initialize in _func.pxi +np.import_array() # Initialize the NumPy C API + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_ACCBANDS( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ ACCBANDS(high, low, close[, timeperiod=?]) + + Acceleration Bands (Overlap Studies) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 20 + Outputs: + upperband + middleband + lowerband + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + int outbegidx + int outnbelement + double outrealupperband + double outrealmiddleband + double outreallowerband + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + length = check_length3(high, low, close) + outrealupperband = NaN + outrealmiddleband = NaN + outreallowerband = NaN + retCode = lib.TA_ACCBANDS( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outrealupperband , &outrealmiddleband , &outreallowerband ) + _ta_check_success("TA_ACCBANDS", retCode) + return outrealupperband , outrealmiddleband , outreallowerband @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function @@ -432,6 +473,35 @@ def stream_AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.nd _ta_check_success("TA_AVGPRICE", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_AVGDEV( np.ndarray real not None , int timeperiod=-2**31 ): + """ AVGDEV(real[, timeperiod=?]) + + Average Deviation (Price Transform) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_AVGDEV( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_AVGDEV", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_BBANDS( np.ndarray real not None , int timeperiod=-2**31 , double nbdevup=-4e37 , double nbdevdn=-4e37 , int matype=0 ): @@ -3273,6 +3343,38 @@ def stream_HT_TRENDMODE( np.ndarray real not None ): _ta_check_success("TA_HT_TRENDMODE", retCode) return outinteger +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_IMI( np.ndarray open not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ IMI(open, close[, timeperiod=?]) + + Intraday Momentum Index (Momentum Indicators) + + Inputs: + prices: ['open', 'close'] + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* open_data + double* close_data + int outbegidx + int outnbelement + double outreal + open = check_array(open) + open_data = open.data + close = check_array(close) + close_data = close.data + length = check_length2(open, close) + outreal = NaN + retCode = lib.TA_IMI( (length) - 1 , (length) - 1 , open_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_IMI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_KAMA( np.ndarray real not None , int timeperiod=-2**31 ): diff --git a/talib/_ta_lib.c b/talib/_ta_lib.c index 4da3957ee..05527f83d 100644 --- a/talib/_ta_lib.c +++ b/talib/_ta_lib.c @@ -1,34 +1,31 @@ -/* Generated by Cython 3.0.10 */ +/* Generated by Cython 3.2.4 */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ -#if defined(CYTHON_LIMITED_API) && 0 - #ifndef Py_LIMITED_API - #if CYTHON_LIMITED_API+0 > 0x03030000 - #define Py_LIMITED_API CYTHON_LIMITED_API - #else - #define Py_LIMITED_API 0x03030000 - #endif +/* InitLimitedAPI */ +#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" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.7+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x03080000 + #error Cython requires Python 3.8+. #else -#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API -#define __PYX_EXTRA_ABI_MODULE_NAME "limited" -#else -#define __PYX_EXTRA_ABI_MODULE_NAME "" -#endif -#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME -#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI -#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -#define CYTHON_HEX_VERSION 0x03000AF0 +#define __PYX_ABI_VERSION "3_2_4" +#define CYTHON_HEX_VERSION 0x030204F0 #define CYTHON_FUTURE_DIVISION 0 +/* CModulePreamble */ #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) @@ -51,9 +48,6 @@ #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 @@ -68,19 +62,13 @@ #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 1 - #define CYTHON_COMPILING_IN_NOGIL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS @@ -91,8 +79,12 @@ #define CYTHON_USE_PYLONG_INTERNALS 0 #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 0 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE @@ -104,42 +96,42 @@ #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 + #define CYTHON_USE_EXC_INFO_STACK 1 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #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 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 + #define CYTHON_USE_TYPE_SLOTS 1 #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS @@ -150,8 +142,13 @@ #define CYTHON_USE_PYLONG_INTERNALS 0 #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 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE @@ -163,7 +160,7 @@ #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #if PY_VERSION_HEX < 0x03090000 #undef CYTHON_PEP489_MULTI_PHASE_INIT @@ -173,17 +170,24 @@ #endif #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) #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 @@ -193,17 +197,13 @@ #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 1 #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_CLINE_IN_TRACEBACK - #define CYTHON_CLINE_IN_TRACEBACK 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS @@ -216,8 +216,13 @@ #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif + #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE @@ -225,71 +230,7 @@ #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 1 - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 -#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #ifndef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 1 - #endif + #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS @@ -301,26 +242,40 @@ #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #ifndef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 + #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 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + #if PY_VERSION_HEX < 0x030A0000 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(CYTHON_USE_TYPE_SLOTS) #define CYTHON_USE_TYPE_SLOTS 1 #endif #ifndef CYTHON_USE_TYPE_SPECS @@ -329,22 +284,19 @@ #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif - #if PY_MAJOR_VERSION < 3 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLIST_INTERNALS) #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif - #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) @@ -353,20 +305,32 @@ #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif - #ifndef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) #endif #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #define CYTHON_METH_FASTCALL 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 @@ -374,51 +338,57 @@ #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif - #if PY_VERSION_HEX < 0x030400a1 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #elif !defined(CYTHON_USE_TP_FINALIZE) + #ifndef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) + #endif + #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif - #if PY_VERSION_HEX < 0x030600B1 + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #elif !defined(CYTHON_USE_DICT_VERSIONS) - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) #endif - #if PY_VERSION_HEX < 0x030700A3 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #ifndef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 1 + #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 -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#ifndef CYTHON_COMPRESS_STRINGS + #define CYTHON_COMPRESS_STRINGS 1 +#endif +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL) #endif -#if !defined(CYTHON_VECTORCALL) -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) #endif -#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS - #if PY_MAJOR_VERSION < 3 - #include "longintrepr.h" - #endif #undef SHIFT #undef BASE #undef MASK @@ -478,7 +448,7 @@ #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 @@ -493,35 +463,8 @@ #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 @@ -553,6 +496,9 @@ #endif #endif #endif +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#endif #ifdef __cplusplus template struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; @@ -561,12 +507,13 @@ #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)) +/* CInitCode */ #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) @@ -581,109 +528,42 @@ #endif #endif +/* PythonCompatibility */ #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" -#if PY_MAJOR_VERSION < 3 - #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_DefaultClassType PyClass_Type - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_DefaultClassType PyType_Type +#define __Pyx_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type #if CYTHON_COMPILING_IN_LIMITED_API - static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyObject *exception_table = NULL; - PyObject *types_module=NULL, *code_type=NULL, *result=NULL; - #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 - PyObject *version_info; - PyObject *py_minor_version = NULL; - #endif - long minor_version = 0; - PyObject *type, *value, *traceback; - PyErr_Fetch(&type, &value, &traceback); - #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 - minor_version = 11; - #else - if (!(version_info = PySys_GetObject("version_info"))) goto end; - if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; - minor_version = PyLong_AsLong(py_minor_version); - Py_DECREF(py_minor_version); - if (minor_version == -1 && PyErr_Occurred()) goto end; - #endif - if (!(types_module = PyImport_ImportModule("types"))) goto end; - if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; - if (minor_version <= 7) { - (void)p; - result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else if (minor_version <= 10) { - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else { - if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); - } - end: - Py_XDECREF(code_type); - Py_XDECREF(exception_table); - Py_XDECREF(types_module); - if (type) { - PyErr_Restore(type, value, traceback); - } - return result; - } #ifndef CO_OPTIMIZED - #define CO_OPTIMIZED 0x0001 + static int CO_OPTIMIZED; #endif #ifndef CO_NEWLOCALS - #define CO_NEWLOCALS 0x0002 + static int CO_NEWLOCALS; #endif #ifndef CO_VARARGS - #define CO_VARARGS 0x0004 + static int CO_VARARGS; #endif #ifndef CO_VARKEYWORDS - #define CO_VARKEYWORDS 0x0008 + static int CO_VARKEYWORDS; #endif #ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x0200 + static int CO_ASYNC_GENERATOR; #endif #ifndef CO_GENERATOR - #define CO_GENERATOR 0x0020 + static int CO_GENERATOR; #endif #ifndef CO_COROUTINE - #define CO_COROUTINE 0x0080 + static int CO_COROUTINE; #endif -#elif PY_VERSION_HEX >= 0x030B0000 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyCodeObject *result; - PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); - if (!empty_bytes) return NULL; - result = - #if PY_VERSION_HEX >= 0x030C0000 - PyUnstable_Code_NewWithPosOnlyArgs - #else - PyCode_NewWithPosOnlyArgs - #endif - (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); - Py_DECREF(empty_bytes); - return result; - } -#elif PY_VERSION_HEX >= 0x030800B2 && !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 - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif #endif +static int __Pyx_init_co_variables(void); #if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) #else @@ -715,12 +595,6 @@ #else #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #endif -#ifndef CO_COROUTINE - #define CO_COROUTINE 0x80 -#endif -#ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x200 -#endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif @@ -739,10 +613,16 @@ #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 -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) +#ifndef METH_FASTCALL #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif @@ -771,16 +651,11 @@ #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)) #endif -#if PY_MAJOR_VERSION >= 0x030900B1 +#if PY_VERSION_HEX >= 0x030900B1 #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) #else #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) @@ -797,7 +672,7 @@ static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; } #endif -static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { #if CYTHON_COMPILING_IN_LIMITED_API return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else @@ -805,7 +680,7 @@ static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { #endif } #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) -#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 +#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 @@ -821,8 +696,13 @@ static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #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)) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) @@ -833,15 +713,11 @@ static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() -#elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() -#elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() #else - #define __Pyx_PyThreadState_Current _PyThreadState_Current + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #endif -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +#if CYTHON_USE_MODULE_STATE +static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) { void *result; result = PyModule_GetState(op); @@ -849,85 +725,43 @@ static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) Py_FatalError("Couldn't find the module state"); return result; } -#endif -#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) #else - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) #endif -#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) -#include "pythread.h" -#define Py_tss_NEEDS_INIT 0 -typedef int Py_tss_t; -static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { - *key = PyThread_create_key(); - return 0; -} -static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { - Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); - *key = Py_tss_NEEDS_INIT; - return key; -} -static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { - PyObject_Free(key); -} -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { - PyThread_delete_key(*key); - *key = Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { - return PyThread_set_key_value(*key, value); -} -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); -} -#endif -#if PY_MAJOR_VERSION < 3 - #if CYTHON_COMPILING_IN_PYPY - #if PYPY_VERSION_NUM < 0x07030600 - #if defined(__cplusplus) && __cplusplus >= 201402L - [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] - #elif defined(__GNUC__) || defined(__clang__) - __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) - #elif defined(_MSC_VER) - __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) - #endif - static CYTHON_INLINE int PyGILState_Check(void) { - return 0; - } - #else // PYPY_VERSION_NUM < 0x07030600 - #endif // PYPY_VERSION_NUM < 0x07030600 - #else - static CYTHON_INLINE int PyGILState_Check(void) { - PyThreadState * tstate = _PyThreadState_Current; - return tstate && (tstate == PyGILState_GetThisThreadState()); - } - #endif -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif -#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); if (res == NULL) PyErr_Clear(); return res; } -#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 #define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError #define __Pyx_PyDict_GetItemStr PyDict_GetItem #else @@ -951,18 +785,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) - #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) #else #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) - #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next #endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) -#else - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) -#endif -#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) +#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));\ @@ -973,24 +801,20 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, #define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif #if CYTHON_COMPILING_IN_LIMITED_API - #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) #define __Pyx_PyUnicode_DATA(u) ((void*)u) #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) -#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 +#else #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_READY(op) (0) #else #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #endif - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) @@ -1006,20 +830,6 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #endif -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) - #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) @@ -1033,8 +843,7 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, #if !defined(PyUnicode_DecodeUnicodeEscape) #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) #endif - #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) - #undef PyUnicode_Contains + #if !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if !defined(PyByteArray_Check) @@ -1044,34 +853,11 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #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 PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) -#else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) -#endif -#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) - #define PyObject_ASCII(o) PyObject_Repr(o) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBaseString_Type PyUnicode_Type - #define PyStringObject PyUnicodeObject - #define PyString_Type PyUnicode_Type - #define PyString_Check PyUnicode_Check - #define PyString_CheckExact PyUnicode_CheckExact -#ifndef PyObject_Unicode - #define PyObject_Unicode PyObject_Str -#endif -#endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) -#else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) -#endif -#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 @@ -1087,115 +873,227 @@ 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 +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_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 +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} +#else +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} +#endif +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) +#endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) +#else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif +#if CYTHON_ASSUME_SAFE_SIZE #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) #else - #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) - #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) - #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) #endif -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult #else - static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { - PyObject *module = PyImport_AddModule(name); - Py_XINCREF(module); - return module; - } + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; #endif -#if PY_MAJOR_VERSION >= 3 - #define PyIntObject PyLongObject - #define PyInt_Type PyLong_Type - #define PyInt_Check(op) PyLong_Check(op) - #define PyInt_CheckExact(op) PyLong_CheckExact(op) - #define __Pyx_Py3Int_Check(op) PyLong_Check(op) - #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) - #define PyInt_FromString PyLong_FromString - #define PyInt_FromUnicode PyLong_FromUnicode - #define PyInt_FromLong PyLong_FromLong - #define PyInt_FromSize_t PyLong_FromSize_t - #define PyInt_FromSsize_t PyLong_FromSsize_t - #define PyInt_AsLong PyLong_AsLong - #define PyInt_AS_LONG PyLong_AS_LONG - #define PyInt_AsSsize_t PyLong_AsSsize_t - #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask - #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask - #define PyNumber_Int PyNumber_Long -#else - #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) - #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject -#endif -#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif -#endif -#if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t -#else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t -#endif -#if CYTHON_USE_ASYNC_SLOTS - #if PY_VERSION_HEX >= 0x030500B1 - #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods - #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) - #else - #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) - #endif +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 #else - #define __Pyx_PyType_AsAsync(obj) NULL +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation #endif -#ifndef __Pyx_PyAsyncMethodsStruct +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} #endif +/* MathInitCode */ #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) - #if !defined(_USE_MATH_DEFINES) + #ifndef _USE_MATH_DEFINES #define _USE_MATH_DEFINES #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 #define __Pyx_truncl truncl #endif -#define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 +#endif +#ifndef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#endif +#if CYTHON_CLINE_IN_TRACEBACK +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; } +#else +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } +#endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } @@ -1245,12 +1143,17 @@ static CYTHON_INLINE float __PYX_NAN() { #define CYTHON_WITHOUT_ASSERTIONS #endif -typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; - const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; - +#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_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize @@ -1293,19 +1196,23 @@ static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); -#if PY_MAJOR_VERSION < 3 - #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#else - #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize -#endif -#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif #define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) @@ -1314,32 +1221,44 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) -#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) #define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) -#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) #else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) #endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) -#else -#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) -#endif #if CYTHON_USE_PYLONG_INTERNALS #if PY_VERSION_HEX >= 0x030C00A7 #ifndef _PyLong_SIGN_MASK @@ -1386,81 +1305,12 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) #endif #endif -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -#include -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; - const char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - if (strcmp(default_encoding_c, "ascii") == 0) { - __Pyx_sys_getdefaultencoding_not_ascii = 0; - } else { - char ascii_chars[128]; - int c; - for (c = 0; c < 128; c++) { - ascii_chars[c] = (char) c; - } - __Pyx_sys_getdefaultencoding_not_ascii = 1; - ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); - if (!ascii_chars_u) goto bad; - ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); - if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { - PyErr_Format( - PyExc_ValueError, - "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", - default_encoding_c); - goto bad; - } - Py_DECREF(ascii_chars_u); - Py_DECREF(ascii_chars_b); - } - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - Py_XDECREF(ascii_chars_u); - Py_XDECREF(ascii_chars_b); - return -1; -} -#endif -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) #else -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#include -static char* __PYX_DEFAULT_STRING_ENCODING; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); - if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; - strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - return -1; -} -#endif + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #endif @@ -1472,14 +1322,30 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ +/* PretendToInitialize */ +#ifdef __cplusplus +#if __cplusplus > 201103L +#include +#endif +template +static void __Pyx_pretend_to_initialize(T* ptr) { +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + #if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; #endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm = __FILE__; +static const char * const __pyx_cfilenm = __FILE__; static const char *__pyx_filename; /* Header.proto */ @@ -1506,21 +1372,185 @@ static const char *__pyx_filename; /* #### Code section: filename_table ### */ -static const char *__pyx_f[] = { +static const char* const __pyx_f[] = { + "talib/_ta_lib.pyx", "talib/_common.pxi", "talib/_abstract.pxi", - "__init__.cython-30.pxd", + ".venv/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd", "talib/_func.pxi", "talib/_stream.pxi", - "talib/_ta_lib.pyx", - "type.pxd", + ".venv/lib/python3.12/site-packages/Cython/Includes/cpython/type.pxd", }; /* #### Code section: utility_code_proto_before_types ### */ -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 +/* Atomics.proto (used by UnpackUnboundCMethod) */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #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) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ +\ + (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #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) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__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) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #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 +#elif CYTHON_ATOMICS && defined(_MSC_VER) + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #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) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + #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 +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif + +/* CriticalSectionsDefinition.proto (used by CriticalSections) */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_End(cs) +#define __Pyx_PyCriticalSection2_End(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#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) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#endif + +/* IncludeStructmemberH.proto (used by FixUpExtensionType) */ +#include + /* #### Code section: numeric_typedefs ### */ typedef npy_int8 __pyx_t_5numpy_int8_t; @@ -1543,12 +1573,8 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; typedef npy_float64 __pyx_t_5numpy_float64_t; -typedef npy_long __pyx_t_5numpy_int_t; - typedef npy_longlong __pyx_t_5numpy_longlong_t; -typedef npy_ulong __pyx_t_5numpy_uint_t; - typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; typedef npy_intp __pyx_t_5numpy_intp_t; @@ -1585,17 +1611,25 @@ static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(floa #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); +/* Declarations.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + typedef ::std::complex< long double > __pyx_t_long_double_complex; + #else + typedef long double _Complex __pyx_t_long_double_complex; + #endif +#else + typedef struct { long double real, imag; } __pyx_t_long_double_complex; +#endif +static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double, long double); + /* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ -typedef npy_cfloat __pyx_t_5numpy_cfloat_t; +typedef int (*__pyx_t_5numpy_NpyIter_IterNextFunc)(NpyIter *); -typedef npy_cdouble __pyx_t_5numpy_cdouble_t; - -typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; - -typedef npy_cdouble __pyx_t_5numpy_complex_t; +typedef void (*__pyx_t_5numpy_NpyIter_GetMultiIndexFunc)(NpyIter *, npy_intp *); /* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ @@ -1615,7 +1649,6 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; -#ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ @@ -1629,11 +1662,6 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t; __Pyx_RefNannyFinishContext();\ PyGILState_Release(__pyx_gilstate_save);\ } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) - #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() -#endif #define __Pyx_RefNannyFinishContextNogil() {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __Pyx_RefNannyFinishContext();\ @@ -1678,7 +1706,7 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t; #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); @@ -1686,7 +1714,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; @@ -1704,7 +1732,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) @@ -1729,20 +1757,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 @@ -1766,147 +1794,246 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif -/* PyObjectCall.proto */ +/* PyImportError_Check.proto */ +#define __Pyx_PyExc_ImportError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ImportError) + +/* 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 -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* 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 **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" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif - #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 - -/* PyObjectCallMethO.proto */ +/* PyObjectCallMethO.proto (used by PyObjectFastCall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectFastCall.proto */ #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 **args, size_t nargs, PyObject *kwargs); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); +/* 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); + +/* 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 + +/* IncludeStdlibH.proto (used by CIntToPyUnicode) */ +#include + +/* IncludeStringH.proto (used by CIntToPyUnicode) */ +#include -/* TupleAndListFromArray.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 (used by fastcall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +#endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif -/* IncludeStringH.proto */ -#include - -/* 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 */ #if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) #elif CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) #else - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) -#endif -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) - #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) -#else - #define __Pyx_Arg_NewRef_VARARGS(arg) arg - #define __Pyx_Arg_XDECREF_VARARGS(arg) + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) #endif #define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) #define __Pyx_KwValues_VARARGS(args, nargs) NULL #define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) #define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) #if CYTHON_METH_FASTCALL - #define __Pyx_Arg_FASTCALL(args, i) args[i] - #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); #else #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) #endif - #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs - to have the same reference counting */ - #define __Pyx_Arg_XDECREF_FASTCALL(arg) #else - #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS - #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) - #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) #endif -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) -#else #define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif -/* 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); +/* py_dict_items.proto (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); + +/* 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)\ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) + +/* 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; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#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); -/* RaiseDoubleKeywords.proto */ +/* 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); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#endif + /* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, - const char* function_name); +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) @@ -1917,7 +2044,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);\ @@ -1937,7 +2064,7 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN #define __Pyx_GetModuleGlobalName(var, name) do {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_mstate_global->__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) @@ -1953,36 +2080,43 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif +/* 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 +#define __Pyx_PyObject_DelAttr(o, n) PyObject_DelAttr(o, n) +#endif + /* PyObjectSetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); #else -#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #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); + int is_list, int wraparound, int boundscheck, int unsafe_shared); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS @@ -1991,18 +2125,27 @@ static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *k #define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); +#endif /* HasAttr.proto */ -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 #define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) #else 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 PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ @@ -2051,44 +2194,26 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif -/* PyObjectCall2Args.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); +/* 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); - -/* PyObjectCallMethod1.proto */ -static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); - -/* StringJoin.proto */ -#if PY_MAJOR_VERSION < 3 -#define __Pyx_PyString_Join __Pyx_PyBytes_Join -#define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v)) -#else -#define __Pyx_PyString_Join PyUnicode_Join -#define __Pyx_PyBaseString_Join PyUnicode_Join #endif -static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); - -/* PyObjectCallNoArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -/* 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 */ -#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ - (likely(is_tuple || PyTuple_Check(tuple)) ?\ - (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ - __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ - (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ - __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) +/* 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( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( @@ -2100,14 +2225,32 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); -/* PyIntBinop.proto */ +/* PyLongBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else -#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ +#define __Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #endif +/* PyObjectVectorCallKwBuilder.proto */ +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall +#endif +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) +#endif + /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { @@ -2129,6 +2272,21 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) #endif +/* PyIndexError_Check.proto */ +#define __Pyx_PyExc_IndexError_Check(obj) __Pyx_TypeCheck(obj, PyExc_IndexError) + +/* CIntToPyUnicode.proto */ +#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 static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); @@ -2138,51 +2296,19 @@ 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 */ -#if PY_MAJOR_VERSION >= 3 #define __Pyx_PyObject_Unicode(obj)\ (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) -#else -#define __Pyx_PyObject_Unicode(obj)\ - (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Unicode(obj)) -#endif /* py_dict_keys.proto */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d); -/* UnpackUnboundCMethod.proto */ -typedef struct { - PyObject *type; - PyObject **method_name; - PyCFunction func; - PyObject *method; - int flag; -} __Pyx_CachedCFunction; - -/* CallUnboundCMethod0.proto */ -static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CallUnboundCMethod0(cfunc, self)\ - (likely((cfunc)->func) ?\ - (likely((cfunc)->flag == METH_NOARGS) ? (*((cfunc)->func))(self, NULL) :\ - (PY_VERSION_HEX >= 0x030600B1 && likely((cfunc)->flag == METH_FASTCALL) ?\ - (PY_VERSION_HEX >= 0x030700A0 ?\ - (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0) :\ - (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL)) :\ - (PY_VERSION_HEX >= 0x030700A0 && (cfunc)->flag == (METH_FASTCALL | METH_KEYWORDS) ?\ - (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL) :\ - (likely((cfunc)->flag == (METH_VARARGS | METH_KEYWORDS)) ? ((*(PyCFunctionWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, __pyx_empty_tuple, NULL)) :\ - ((cfunc)->flag == METH_VARARGS ? (*((cfunc)->func))(self, __pyx_empty_tuple) :\ - __Pyx__CallUnboundCMethod0(cfunc, self)))))) :\ - __Pyx__CallUnboundCMethod0(cfunc, self)) -#else -#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) -#endif - -/* PyNumberPow2.proto */ -#define __Pyx_PyNumber_InPlacePowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 1) -#define __Pyx_PyNumber_PowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 0) -static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace); +/* 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( @@ -2190,104 +2316,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); -/* PyIntBinop.proto */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_RemainderObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); -#else -#define __Pyx_PyInt_RemainderObjC(op1, op2, intval, inplace, zerodivision_check)\ - (inplace ? PyNumber_InPlaceRemainder(op1, op2) : PyNumber_Remainder(op1, op2)) -#endif - -/* PyIntCompare.proto */ -static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); - -/* StrEquals.proto */ -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals -#else -#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals -#endif - /* 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_0_10 -#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#ifndef __PYX_HAVE_RT_ImportType_proto_3_2_4 +#define __PYX_HAVE_RT_ImportType_proto_3_2_4 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L #include #endif #if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L -#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#define __PYX_GET_STRUCT_ALIGNMENT_3_2_4(s) alignof(s) #else -#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#define __PYX_GET_STRUCT_ALIGNMENT_3_2_4(s) sizeof(void*) #endif -enum __Pyx_ImportType_CheckSize_3_0_10 { - __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, - __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, - __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 +enum __Pyx_ImportType_CheckSize_3_2_4 { + __Pyx_ImportType_CheckSize_Error_3_2_4 = 0, + __Pyx_ImportType_CheckSize_Warn_3_2_4 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_2_4 = 2 }; -static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); +static PyTypeObject *__Pyx_ImportType_3_2_4(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_4 check_size); #endif -/* IncludeStructmemberH.proto */ -#include +/* dict_setdefault.proto (used by FetchCommonType) */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value); -/* FixUpExtensionType.proto */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +/* LimitedApiGetTypeDict.proto (used by SetItemOnTypeDict) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); #endif -/* FetchSharedCythonModule.proto */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void); +/* 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); -/* FetchCommonType.proto */ -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +/* 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 -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) #endif -/* PyMethodNew.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - typesModule = PyImport_ImportModule("types"); - if (!typesModule) return NULL; - methodType = PyObject_GetAttrString(typesModule, "MethodType"); - Py_DECREF(typesModule); - if (!methodType) return NULL; - result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); - Py_DECREF(methodType); - return result; -} -#elif PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - return PyMethod_New(func, self); -} +/* FetchSharedCythonModule.proto (used by FetchCommonType) */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto (used by CommonTypesMetaclass) */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, 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 (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 - #define __Pyx_PyMethod_New PyMethod_New +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); #endif -/* PyVectorcallFastCallDict.proto */ -#if CYTHON_METH_FASTCALL +/* PyMethodNew.proto (used by CythonFunctionShared) */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* 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 @@ -2317,13 +2423,15 @@ typedef struct { #else PyCMethodObject func; #endif -#if CYTHON_BACKPORT_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL __pyx_vectorcallfunc func_vectorcall; #endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#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; @@ -2333,9 +2441,7 @@ typedef struct { #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API PyObject *func_classobj; #endif - void *defaults; - int defaults_pyobjects; - size_t defaults_size; + PyObject *defaults; int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; @@ -2344,10 +2450,10 @@ typedef struct { PyObject *func_is_coroutine; } __pyx_CyFunctionObject; #undef __Pyx_CyOrPyCFunction_Check -#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) -#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) -#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); #undef __Pyx_IsSameCFunction #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, @@ -2356,9 +2462,8 @@ static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef * PyObject *module, PyObject *globals, PyObject* code); static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, - size_t size, - int pyobjects); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, PyObject *tuple); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, @@ -2371,7 +2476,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 +#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) @@ -2392,7 +2497,7 @@ static PyObject* __Pyx_PEP560_update_bases(PyObject *bases); static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); /* SetNameInClass.proto */ -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value)) #elif CYTHON_COMPILING_IN_CPYTHON @@ -2402,7 +2507,10 @@ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bas #define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) #endif -/* PyObjectLookupSpecial.proto */ +/* PyObjectCall2Args.proto (used by Py3ClassCreate) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* 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) @@ -2418,57 +2526,63 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); +/* 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); -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); -#endif - -/* ImportDottedModuleRelFirst.proto */ -static PyObject *__Pyx_ImportDottedModuleRelFirst(PyObject *name, PyObject *parts_tuple); +/* 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 */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else +/* 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 */ -#if !CYTHON_COMPILING_IN_LIMITED_API +/* CodeObjectCache.proto (used by AddTraceback) */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif typedef struct { - PyCodeObject* code_object; + __Pyx_CachedCodeObjectType* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_int_type accessor_count; + #endif }; -static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); -static PyCodeObject *__pyx_find_code_object(int code_line); -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); -#endif +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); -/* GCCDiagnostics.proto */ -#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define __Pyx_HAS_GCC_DIAGNOSTIC -#endif - /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus @@ -2567,66 +2681,105 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, #endif #endif -/* CIntFromPy.proto */ -static CYTHON_INLINE TA_RetCode __Pyx_PyInt_As_TA_RetCode(PyObject *); +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #define __Pyx_c_eq_long__double(a, b) ((a)==(b)) + #define __Pyx_c_sum_long__double(a, b) ((a)+(b)) + #define __Pyx_c_diff_long__double(a, b) ((a)-(b)) + #define __Pyx_c_prod_long__double(a, b) ((a)*(b)) + #define __Pyx_c_quot_long__double(a, b) ((a)/(b)) + #define __Pyx_c_neg_long__double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_long__double(z) ((z)==(long double)0) + #define __Pyx_c_conj_long__double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_long__double(z) (::std::abs(z)) + #define __Pyx_c_pow_long__double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_long__double(z) ((z)==0) + #define __Pyx_c_conj_long__double(z) (conjl(z)) + #if 1 + #define __Pyx_c_abs_long__double(z) (cabsl(z)) + #define __Pyx_c_pow_long__double(a, b) (cpowl(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex); + #if 1 + static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + #endif +#endif /* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +static CYTHON_INLINE TA_RetCode __Pyx_PyLong_As_TA_RetCode(PyObject *); -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_RetCode(TA_RetCode value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); /* CIntFromPy.proto */ -static CYTHON_INLINE TA_FuncUnstId __Pyx_PyInt_As_TA_FuncUnstId(PyObject *); +static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *); /* CIntFromPy.proto */ -static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); +static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *); /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value); /* CIntFromPy.proto */ -static CYTHON_INLINE TA_Compatibility __Pyx_PyInt_As_TA_Compatibility(PyObject *); +static CYTHON_INLINE TA_Compatibility __Pyx_PyLong_As_TA_Compatibility(PyObject *); /* CIntFromPy.proto */ -static CYTHON_INLINE TA_CandleSettingType __Pyx_PyInt_As_TA_CandleSettingType(PyObject *); +static CYTHON_INLINE TA_CandleSettingType __Pyx_PyLong_As_TA_CandleSettingType(PyObject *); /* CIntFromPy.proto */ -static CYTHON_INLINE TA_RangeType __Pyx_PyInt_As_TA_RangeType(PyObject *); +static CYTHON_INLINE TA_RangeType __Pyx_PyLong_As_TA_RangeType(PyObject *); /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInputParameterType value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInputParameterType value); /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_FuncFlags(TA_FuncFlags value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_FuncFlags(TA_FuncFlags value); /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_InputFlags(TA_InputFlags value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_InputFlags(TA_InputFlags value); /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags value); +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OutputFlags(TA_OutputFlags value); /* FormatTypeName.proto */ #if CYTHON_COMPILING_IN_LIMITED_API typedef PyObject *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%U" -static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); #define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName #else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#endif +#else // !LIMITED_API typedef const char *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%.200s" -#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) #define __Pyx_DECREF_TypeName(obj) #endif /* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON @@ -2640,19 +2793,92 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} #endif #define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) +#else + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) +#endif -/* CheckBinaryVersion.proto */ +/* 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); -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* 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*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif /* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." + +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*/ +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self); /* proto*/ @@ -2708,944 +2934,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_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_3[] = "3"; -static const char __pyx_k_b[] = "b"; -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__6[] = ""; -static const char __pyx_k__7[] = ", "; -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_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_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_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_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[] = ")\n"; -static const char __pyx_k__12[] = "\n"; -static const char __pyx_k__43[] = "."; -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_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_s_s[] = " %s: %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_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_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__240[] = "*"; -static const char __pyx_k__503[] = "?"; -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_dict[] = "__dict__"; -static const char __pyx_k_docs[] = "docs"; -static const char __pyx_k_flag[] = "flag"; -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_join[] = "join"; -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_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_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_s_s_2[] = "[%s=%s]"; -static const char __pyx_k_super[] = "super"; -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_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_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_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_import[] = "__import__"; -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_xrange[] = "xrange"; -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_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_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_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_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_defaults[] = "defaults"; -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_set_name[] = "__set_name__"; -static const char __pyx_k_to_numpy[] = "to_numpy"; -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_RangeType[] = "RangeType"; -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_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_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_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_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_init_subclass[] = "__init_subclass__"; -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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_Unknown_Error_TA_UNKNOWN_ERR[] = "Unknown Error (TA_UNKNOWN_ERR)"; -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_Function___get_opt_input_value[] = "Function.__get_opt_input_value"; -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_input_array_type_is_not_double[] = "input array type is not double"; -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_Kaufman_Adaptive_Moving_Average[] = "Kaufman Adaptive Moving Average"; -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_TA_RestoreCandleDefaultSettings[] = "TA_RestoreCandleDefaultSettings"; -static const char __pyx_k_This_is_a_pythonic_wrapper_arou[] = "\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 set_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 programatically 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 "; -static const char __pyx_k_Values_represent_an_upper_limit[] = "Values represent an upper limit"; -static const char __pyx_k_integer_values_are_100_0_or_100[] = "integer (values are -100, 0 or 100)"; -static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; -static const char __pyx_k_s_function_failed_with_error_co[] = "%s function failed with error code %s: %s"; -static const char __pyx_k_ta_restore_candle_default_setti[] = "_ta_restore_candle_default_settings"; -static const char __pyx_k_Bull_Bear_Pattern_Bearish_0_Neut[] = "Bull/Bear Pattern (Bearish < 0, Neutral = 0, Bullish > 0)"; -static const char __pyx_k_Double_Exponential_Moving_Averag[] = "Double Exponential Moving Average"; -static const char __pyx_k_Function_Not_Found_TA_FUNC_NOT_F[] = "Function Not Found (TA_FUNC_NOT_FOUND)"; -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_Group_Not_Found_TA_GROUP_NOT_FOU[] = "Group Not Found (TA_GROUP_NOT_FOUND)"; -static const char __pyx_k_Input_Not_All_Initialized_TA_INP[] = "Input Not All Initialized (TA_INPUT_NOT_ALL_INITIALIZE)"; -static const char __pyx_k_Internal_Error_TA_INTERNAL_ERROR[] = "Internal Error (TA_INTERNAL_ERROR)"; -static const char __pyx_k_Invalid_Handle_TA_INVALID_HANDLE[] = "Invalid Handle (TA_INVALID_HANDLE)"; -static const char __pyx_k_Invalid_List_Type_TA_INVALID_LIS[] = "Invalid List Type (TA_INVALID_LIST_TYPE)"; -static const char __pyx_k_Invalid_Parameter_Function_TA_IN[] = "Invalid Parameter Function (TA_INVALID_PARAM_FUNCTION)"; -static const char __pyx_k_Invalid_Parameter_Holder_TA_INVA[] = "Invalid Parameter Holder (TA_INVALID_PARAM_HOLDER)"; -static const char __pyx_k_Invalid_Parameter_Holder_Type_TA[] = "Invalid Parameter Holder Type (TA_INVALID_PARAM_HOLDER_TYPE)"; -static const char __pyx_k_Invalid_parameter_value_for_s_ex[] = "Invalid parameter value for %s (expected %s, got %s)"; -static const char __pyx_k_Library_Not_Initialized_TA_LIB_N[] = "Library Not Initialized (TA_LIB_NOT_INITIALIZE)"; -static const char __pyx_k_Not_enough_price_arguments_expec[] = "Not enough price arguments: expected %d (%s)"; -static const char __pyx_k_Out_of_Range_End_Index_TA_OUT_OF[] = "Out-of-Range End Index (TA_OUT_OF_RANGE_END_INDEX)"; -static const char __pyx_k_Output_Not_All_Initialized_TA_OU[] = "Output Not All Initialized (TA_OUTPUT_NOT_ALL_INITIALIZE)"; -static const char __pyx_k_Strength_Pattern_200_100_Bearish[] = "Strength Pattern ([-200..-100] = Bearish, [-100..0] = Getting Bearish, 0 = Neutral, [0..100] = Getting Bullish, [100-200] = Bullish)"; -static const char __pyx_k_Too_many_price_arguments_expecte[] = "Too many price arguments: expected %d (%s)"; -static const char __pyx_k_Triple_Exponential_Moving_Averag[] = "Triple Exponential Moving Average"; -static const char __pyx_k_Triple_Generalized_Double_Expone[] = "Triple Generalized Double Exponential Moving Average"; -static const char __pyx_k_input_array_has_wrong_dimensions[] = "input array has wrong dimensions"; -static const char __pyx_k_input_array_lengths_are_differen[] = "input array lengths are different"; -static const char __pyx_k_input_arrays_parameter_missing_r[] = "input_arrays parameter missing required data key%s: %s"; -static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; /* #### Code section: decls ### */ static PyObject *__pyx_pf_5talib_7_ta_lib__ta_check_success(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_function_name, TA_RetCode __pyx_v_ret_code); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_2_ta_initialize(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ @@ -3658,168 +2951,171 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(CYTHON_UNUSED static PyObject *__pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_14_ta_set_candle_settings(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_settingtype, PyObject *__pyx_v_rangetype, PyObject *__pyx_v_avgperiod, PyObject *__pyx_v_factor); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_settingtype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_18ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_20AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_22ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_24ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_26ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_28ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_30APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_32AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_34AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_36ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_38ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_40ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_44BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_52CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_174CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_176CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_178CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_180COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_182COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_184DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_186DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_188DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_190EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_192EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_194FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_224MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_226MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_228MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_230MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_232MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_234MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_236MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_242MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_246MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_248MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_250MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_254MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_256MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_258MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_264OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_270PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_272ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_274ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_276ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_278ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_280RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_286SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_288SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_290SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_292SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_294STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_296STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_298STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_300STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_304SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_306T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_308TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_310TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_312TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_316TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_318TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_320TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_324ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_326VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_328WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_332WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_334str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_336bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_338str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_340bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_18ACCBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_20ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_22AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_24ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_26ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_28ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_30ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_32APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_34AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_36AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_38ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_40ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_42ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_44AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_46AVGDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_48BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_50BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_52BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_54CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_66CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_68CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_178CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_180CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_182CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_184COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_186COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_188DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_190DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_192DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_194EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_196EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_198FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_208HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_210HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_212IMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_214KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_218LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_220LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_222LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_224LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_226LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_228MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_230MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_232MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_234MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_236MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_238MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_240MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_242MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_244MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_246MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_248MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_250MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_252MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_254MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_256MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_258MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_260MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_262MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_264MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_266MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_268NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_270OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_272PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_274PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_276PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_278ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_280ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_282ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_284ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_286RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_288SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_290SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_292SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_294SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_296SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_298SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_300STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_302STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_304STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_306STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_308SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_310SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_312T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_314TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_316TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_318TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_320TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_322TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_324TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_326TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_328TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_330ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_332VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_334WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_336WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_338WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_340str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_342bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_344str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_346bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_function_name, PyObject *__pyx_v_func_object, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_4info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ @@ -3844,175 +3140,188 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(CYTH static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_42__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_46__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_group); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flag, PyObject *__pyx_v_flags_lookup_dict); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getFuncInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_356_get_defaults_and_docs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_func_info); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_358stream_ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_360stream_AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_362stream_ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_534stream_FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ -static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ -static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_keys = {0, 0, 0, 0, 0}; +static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getGroupTable(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getFuncTable(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_group); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flag, PyObject *__pyx_v_flags_lookup_dict); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_func_info); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ACCBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_AVGDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_534stream_DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_IMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_674stream_TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_676stream_ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_678stream_VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_680stream_WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_682stream_WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */ +static PyObject *__pyx_pf_5talib_7_ta_lib_684stream_WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */ /* #### Code section: late_includes ### */ /* #### Code section: module_state ### */ +/* SmallCodeConfig */ +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + typedef struct { PyObject *__pyx_d; PyObject *__pyx_b; @@ -4020,43 +3329,7 @@ typedef struct { PyObject *__pyx_empty_tuple; PyObject *__pyx_empty_bytes; PyObject *__pyx_empty_unicode; - #ifdef __Pyx_CyFunction_USED - PyTypeObject *__pyx_CyFunctionType; - #endif - #ifdef __Pyx_FusedFunction_USED - PyTypeObject *__pyx_FusedFunctionType; - #endif - #ifdef __Pyx_Generator_USED - PyTypeObject *__pyx_GeneratorType; - #endif - #ifdef __Pyx_IterableCoroutine_USED - PyTypeObject *__pyx_IterableCoroutineType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineAwaitType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineType; - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif PyTypeObject *__pyx_ptype_7cpython_4type_type; - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif PyTypeObject *__pyx_ptype_5numpy_dtype; PyTypeObject *__pyx_ptype_5numpy_flatiter; PyTypeObject *__pyx_ptype_5numpy_broadcast; @@ -4072,1481 +3345,1233 @@ typedef struct { PyTypeObject *__pyx_ptype_5numpy_flexible; PyTypeObject *__pyx_ptype_5numpy_character; PyTypeObject *__pyx_ptype_5numpy_ufunc; - #if CYTHON_USE_MODULE_STATE - #endif - PyObject *__pyx_kp_s_3; - PyObject *__pyx_n_s_ACOS; - PyObject *__pyx_n_s_AD; - PyObject *__pyx_n_s_ADD; - PyObject *__pyx_n_s_ADOSC; - PyObject *__pyx_n_s_ADX; - PyObject *__pyx_n_s_ADXR; - PyObject *__pyx_n_s_ALL; - PyObject *__pyx_n_s_APO; - PyObject *__pyx_n_s_AROON; - PyObject *__pyx_n_s_AROONOSC; - PyObject *__pyx_n_s_ARRAY_TYPES; - PyObject *__pyx_n_s_ASIN; - PyObject *__pyx_n_s_ATAN; - PyObject *__pyx_n_s_ATR; - PyObject *__pyx_n_s_AVGPRICE; - PyObject *__pyx_n_s_AllCandleSettings; - PyObject *__pyx_kp_s_Allocation_Error_TA_ALLOC_ERR; - PyObject *__pyx_n_s_BBANDS; - PyObject *__pyx_n_s_BETA; - PyObject *__pyx_n_s_BOP; - PyObject *__pyx_kp_s_Bad_Object_TA_BAD_OBJECT; - PyObject *__pyx_kp_s_Bad_Parameter_TA_BAD_PARAM; - PyObject *__pyx_n_s_BodyDoji; - PyObject *__pyx_n_s_BodyLong; - PyObject *__pyx_n_s_BodyShort; - PyObject *__pyx_n_s_BodyVeryLong; - PyObject *__pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut; - PyObject *__pyx_n_s_CCI; - PyObject *__pyx_n_s_CDL2CROWS; - PyObject *__pyx_n_s_CDL3BLACKCROWS; - PyObject *__pyx_n_s_CDL3INSIDE; - PyObject *__pyx_n_s_CDL3LINESTRIKE; - PyObject *__pyx_n_s_CDL3OUTSIDE; - PyObject *__pyx_n_s_CDL3STARSINSOUTH; - PyObject *__pyx_n_s_CDL3WHITESOLDIERS; - PyObject *__pyx_n_s_CDLABANDONEDBABY; - PyObject *__pyx_n_s_CDLADVANCEBLOCK; - PyObject *__pyx_n_s_CDLBELTHOLD; - PyObject *__pyx_n_s_CDLBREAKAWAY; - PyObject *__pyx_n_s_CDLCLOSINGMARUBOZU; - PyObject *__pyx_n_s_CDLCONCEALBABYSWALL; - PyObject *__pyx_n_s_CDLCOUNTERATTACK; - PyObject *__pyx_n_s_CDLDARKCLOUDCOVER; - PyObject *__pyx_n_s_CDLDOJI; - PyObject *__pyx_n_s_CDLDOJISTAR; - PyObject *__pyx_n_s_CDLDRAGONFLYDOJI; - PyObject *__pyx_n_s_CDLENGULFING; - PyObject *__pyx_n_s_CDLEVENINGDOJISTAR; - PyObject *__pyx_n_s_CDLEVENINGSTAR; - PyObject *__pyx_n_s_CDLGAPSIDESIDEWHITE; - PyObject *__pyx_n_s_CDLGRAVESTONEDOJI; - PyObject *__pyx_n_s_CDLHAMMER; - PyObject *__pyx_n_s_CDLHANGINGMAN; - PyObject *__pyx_n_s_CDLHARAMI; - PyObject *__pyx_n_s_CDLHARAMICROSS; - PyObject *__pyx_n_s_CDLHIGHWAVE; - PyObject *__pyx_n_s_CDLHIKKAKE; - PyObject *__pyx_n_s_CDLHIKKAKEMOD; - PyObject *__pyx_n_s_CDLHOMINGPIGEON; - PyObject *__pyx_n_s_CDLIDENTICAL3CROWS; - PyObject *__pyx_n_s_CDLINNECK; - PyObject *__pyx_n_s_CDLINVERTEDHAMMER; - PyObject *__pyx_n_s_CDLKICKING; - PyObject *__pyx_n_s_CDLKICKINGBYLENGTH; - PyObject *__pyx_n_s_CDLLADDERBOTTOM; - PyObject *__pyx_n_s_CDLLONGLEGGEDDOJI; - PyObject *__pyx_n_s_CDLLONGLINE; - PyObject *__pyx_n_s_CDLMARUBOZU; - PyObject *__pyx_n_s_CDLMATCHINGLOW; - PyObject *__pyx_n_s_CDLMATHOLD; - PyObject *__pyx_n_s_CDLMORNINGDOJISTAR; - PyObject *__pyx_n_s_CDLMORNINGSTAR; - PyObject *__pyx_n_s_CDLONNECK; - PyObject *__pyx_n_s_CDLPIERCING; - PyObject *__pyx_n_s_CDLRICKSHAWMAN; - PyObject *__pyx_n_s_CDLRISEFALL3METHODS; - PyObject *__pyx_n_s_CDLSEPARATINGLINES; - PyObject *__pyx_n_s_CDLSHOOTINGSTAR; - PyObject *__pyx_n_s_CDLSHORTLINE; - PyObject *__pyx_n_s_CDLSPINNINGTOP; - PyObject *__pyx_n_s_CDLSTALLEDPATTERN; - PyObject *__pyx_n_s_CDLSTICKSANDWICH; - PyObject *__pyx_n_s_CDLTAKURI; - PyObject *__pyx_n_s_CDLTASUKIGAP; - PyObject *__pyx_n_s_CDLTHRUSTING; - PyObject *__pyx_n_s_CDLTRISTAR; - PyObject *__pyx_n_s_CDLUNIQUE3RIVER; - PyObject *__pyx_n_s_CDLUPSIDEGAP2CROWS; - PyObject *__pyx_n_s_CDLXSIDEGAP3METHODS; - PyObject *__pyx_n_s_CEIL; - PyObject *__pyx_n_s_CMO; - PyObject *__pyx_n_s_CORREL; - PyObject *__pyx_n_s_COS; - PyObject *__pyx_n_s_COSH; - PyObject *__pyx_n_s_CandleSettingType; - PyObject *__pyx_n_s_DEMA; - PyObject *__pyx_n_s_DIV; - PyObject *__pyx_n_s_DX; - PyObject *__pyx_kp_s_Dashed_Line; - PyObject *__pyx_n_s_DataFrame; - PyObject *__pyx_n_s_Dot; - PyObject *__pyx_kp_s_Dotted_Line; - PyObject *__pyx_kp_s_Double_Exponential_Moving_Averag; - PyObject *__pyx_n_s_EMA; - PyObject *__pyx_n_s_EXP; - PyObject *__pyx_n_s_Equal; - PyObject *__pyx_kp_s_Exponential_Moving_Average; - PyObject *__pyx_n_s_FLOOR; - PyObject *__pyx_n_s_Far; - PyObject *__pyx_n_s_Function; - PyObject *__pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F; - PyObject *__pyx_n_s_Function___call; - PyObject *__pyx_n_s_Function___call_function; - PyObject *__pyx_n_s_Function___check_opt_input_value; - PyObject *__pyx_n_s_Function___get_opt_input_value; - PyObject *__pyx_n_s_Function___init; - PyObject *__pyx_n_s_Function___input_price_series_na; - PyObject *__pyx_n_s_Function___local; - PyObject *__pyx_n_s_Function___repr; - PyObject *__pyx_n_s_Function___str; - PyObject *__pyx_n_s_Function___unicode; - PyObject *__pyx_n_s_Function__call_function; - PyObject *__pyx_n_s_Function__check_opt_input_value; - PyObject *__pyx_n_s_Function__get_opt_input_value; - PyObject *__pyx_n_s_Function__input_price_series_na; - PyObject *__pyx_n_s_Function__local; - PyObject *__pyx_n_s_Function__localdata; - PyObject *__pyx_n_s_Function__name; - PyObject *__pyx_n_s_Function__namestr; - PyObject *__pyx_n_s_Function_function_flags; - PyObject *__pyx_n_s_Function_get_input_arrays; - PyObject *__pyx_n_s_Function_get_input_names; - PyObject *__pyx_n_s_Function_get_parameters; - PyObject *__pyx_kp_s_Function_has_an_unstable_period; - PyObject *__pyx_n_s_Function_info; - PyObject *__pyx_n_s_Function_lookback; - PyObject *__pyx_n_s_Function_output_flags; - PyObject *__pyx_n_s_Function_output_names; - PyObject *__pyx_n_s_Function_outputs; - PyObject *__pyx_n_s_Function_run; - PyObject *__pyx_n_s_Function_set_function_args; - PyObject *__pyx_n_s_Function_set_input_arrays; - PyObject *__pyx_n_s_Function_set_input_names; - PyObject *__pyx_n_s_Function_set_parameters; - PyObject *__pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU; - PyObject *__pyx_n_s_HT_DCPERIOD; - PyObject *__pyx_n_s_HT_DCPHASE; - PyObject *__pyx_n_s_HT_PHASOR; - PyObject *__pyx_n_s_HT_SINE; - PyObject *__pyx_n_s_HT_TRENDLINE; - PyObject *__pyx_n_s_HT_TRENDMODE; - PyObject *__pyx_n_s_HighLow; - PyObject *__pyx_n_s_Histogram; - PyObject *__pyx_n_s_INPUT_ARRAYS_TYPES; - PyObject *__pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS; - PyObject *__pyx_n_s_ImportError; - PyObject *__pyx_n_s_IndexError; - PyObject *__pyx_kp_s_Input_Not_All_Initialized_TA_INP; - PyObject *__pyx_kp_s_Inputs; - PyObject *__pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR; - PyObject *__pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE; - PyObject *__pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS; - PyObject *__pyx_kp_s_Invalid_Parameter_Function_TA_IN; - PyObject *__pyx_kp_s_Invalid_Parameter_Holder_TA_INVA; - PyObject *__pyx_kp_s_Invalid_Parameter_Holder_Type_TA; - PyObject *__pyx_kp_s_Invalid_parameter_value_for_s_ex; - PyObject *__pyx_n_s_KAMA; - PyObject *__pyx_kp_s_Kaufman_Adaptive_Moving_Average; - PyObject *__pyx_n_s_LINEARREG; - PyObject *__pyx_n_s_LINEARREG_ANGLE; - PyObject *__pyx_n_s_LINEARREG_INTERCEPT; - PyObject *__pyx_n_s_LINEARREG_SLOPE; - PyObject *__pyx_n_s_LN; - PyObject *__pyx_n_s_LOG10; - PyObject *__pyx_kp_s_Library_Not_Initialized_TA_LIB_N; - PyObject *__pyx_n_s_Line; - PyObject *__pyx_n_s_MA; - PyObject *__pyx_n_s_MACD; - PyObject *__pyx_n_s_MACDEXT; - PyObject *__pyx_n_s_MACDFIX; - PyObject *__pyx_n_s_MAMA; - PyObject *__pyx_n_s_MAVP; - PyObject *__pyx_n_s_MAX; - PyObject *__pyx_n_s_MAXINDEX; - PyObject *__pyx_n_s_MA_Type; - PyObject *__pyx_n_s_MA_Type___getitem; - PyObject *__pyx_n_s_MA_Type___init; - PyObject *__pyx_n_s_MEDPRICE; - PyObject *__pyx_kp_s_MESA_Adaptive_Moving_Average; - PyObject *__pyx_n_s_MFI; - PyObject *__pyx_n_s_MIDPOINT; - PyObject *__pyx_n_s_MIDPRICE; - PyObject *__pyx_n_s_MIN; - PyObject *__pyx_n_s_MININDEX; - PyObject *__pyx_n_s_MINMAX; - PyObject *__pyx_n_s_MINMAXINDEX; - PyObject *__pyx_n_s_MINUS_DI; - PyObject *__pyx_n_s_MINUS_DM; - PyObject *__pyx_n_s_MOM; - PyObject *__pyx_n_s_MULT; - PyObject *__pyx_n_s_NATR; - PyObject *__pyx_n_s_NONE; - PyObject *__pyx_n_s_Near; - PyObject *__pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED; - PyObject *__pyx_kp_s_Not_enough_price_arguments_expec; - PyObject *__pyx_n_s_OBV; - PyObject *__pyx_n_s_OrderedDict; - PyObject *__pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF; - PyObject *__pyx_kp_s_Out_of_Range_Start_Index_TA_OUT; - PyObject *__pyx_kp_s_Output_Not_All_Initialized_TA_OU; - PyObject *__pyx_kp_s_Output_can_be_negative; - PyObject *__pyx_kp_s_Output_can_be_positive; - PyObject *__pyx_kp_s_Output_can_be_zero; - PyObject *__pyx_kp_s_Output_is_a_candlestick; - PyObject *__pyx_kp_s_Output_is_over_volume; - PyObject *__pyx_kp_s_Output_scale_same_as_input; - PyObject *__pyx_kp_s_Outputs; - PyObject *__pyx_n_s_PANDAS_DATAFRAME; - PyObject *__pyx_n_s_PANDAS_SERIES; - PyObject *__pyx_n_s_PLUS_DI; - PyObject *__pyx_n_s_PLUS_DM; - PyObject *__pyx_n_s_POLARS_DATAFRAME; - PyObject *__pyx_n_s_POLARS_SERIES; - PyObject *__pyx_n_s_PPO; - PyObject *__pyx_kp_s_Parameters; - PyObject *__pyx_kp_s_Pattern_Bool; - PyObject *__pyx_n_s_ROC; - PyObject *__pyx_n_s_ROCP; - PyObject *__pyx_n_s_ROCR; - PyObject *__pyx_n_s_ROCR100; - PyObject *__pyx_n_s_RSI; - PyObject *__pyx_n_s_RangeType; - PyObject *__pyx_n_s_RealBody; - PyObject *__pyx_n_s_SAR; - PyObject *__pyx_n_s_SAREXT; - PyObject *__pyx_n_s_SIN; - PyObject *__pyx_n_s_SINH; - PyObject *__pyx_n_s_SMA; - PyObject *__pyx_n_s_SQRT; - PyObject *__pyx_n_s_STDDEV; - PyObject *__pyx_n_s_STOCH; - PyObject *__pyx_n_s_STOCHF; - PyObject *__pyx_n_s_STOCHRSI; - PyObject *__pyx_n_s_SUB; - PyObject *__pyx_n_s_SUM; - PyObject *__pyx_n_s_Series; - PyObject *__pyx_n_s_ShadowLong; - PyObject *__pyx_n_s_ShadowShort; - PyObject *__pyx_n_s_ShadowVeryLong; - PyObject *__pyx_n_s_ShadowVeryShort; - PyObject *__pyx_n_s_Shadows; - PyObject *__pyx_kp_s_Simple_Moving_Average; - PyObject *__pyx_kp_s_Strength_Pattern_200_100_Bearish; - PyObject *__pyx_n_s_T3; - PyObject *__pyx_n_s_TAN; - PyObject *__pyx_n_s_TANH; - PyObject *__pyx_n_s_TA_ACOS; - PyObject *__pyx_n_s_TA_AD; - PyObject *__pyx_n_s_TA_ADD; - PyObject *__pyx_n_s_TA_ADOSC; - PyObject *__pyx_n_s_TA_ADX; - PyObject *__pyx_n_s_TA_ADXR; - PyObject *__pyx_n_s_TA_APO; - PyObject *__pyx_n_s_TA_AROON; - PyObject *__pyx_n_s_TA_AROONOSC; - PyObject *__pyx_n_s_TA_ASIN; - PyObject *__pyx_n_s_TA_ATAN; - PyObject *__pyx_n_s_TA_ATR; - PyObject *__pyx_n_s_TA_AVGPRICE; - PyObject *__pyx_n_s_TA_BBANDS; - PyObject *__pyx_n_s_TA_BETA; - PyObject *__pyx_n_s_TA_BOP; - PyObject *__pyx_n_s_TA_CCI; - PyObject *__pyx_n_s_TA_CDL2CROWS; - PyObject *__pyx_n_s_TA_CDL3BLACKCROWS; - PyObject *__pyx_n_s_TA_CDL3INSIDE; - PyObject *__pyx_n_s_TA_CDL3LINESTRIKE; - PyObject *__pyx_n_s_TA_CDL3OUTSIDE; - PyObject *__pyx_n_s_TA_CDL3STARSINSOUTH; - PyObject *__pyx_n_s_TA_CDL3WHITESOLDIERS; - PyObject *__pyx_n_s_TA_CDLABANDONEDBABY; - PyObject *__pyx_n_s_TA_CDLADVANCEBLOCK; - PyObject *__pyx_n_s_TA_CDLBELTHOLD; - PyObject *__pyx_n_s_TA_CDLBREAKAWAY; - PyObject *__pyx_n_s_TA_CDLCLOSINGMARUBOZU; - PyObject *__pyx_n_s_TA_CDLCONCEALBABYSWALL; - PyObject *__pyx_n_s_TA_CDLCOUNTERATTACK; - PyObject *__pyx_n_s_TA_CDLDARKCLOUDCOVER; - PyObject *__pyx_n_s_TA_CDLDOJI; - PyObject *__pyx_n_s_TA_CDLDOJISTAR; - PyObject *__pyx_n_s_TA_CDLDRAGONFLYDOJI; - PyObject *__pyx_n_s_TA_CDLENGULFING; - PyObject *__pyx_n_s_TA_CDLEVENINGDOJISTAR; - PyObject *__pyx_n_s_TA_CDLEVENINGSTAR; - PyObject *__pyx_n_s_TA_CDLGAPSIDESIDEWHITE; - PyObject *__pyx_n_s_TA_CDLGRAVESTONEDOJI; - PyObject *__pyx_n_s_TA_CDLHAMMER; - PyObject *__pyx_n_s_TA_CDLHANGINGMAN; - PyObject *__pyx_n_s_TA_CDLHARAMI; - PyObject *__pyx_n_s_TA_CDLHARAMICROSS; - PyObject *__pyx_n_s_TA_CDLHIGHWAVE; - PyObject *__pyx_n_s_TA_CDLHIKKAKE; - PyObject *__pyx_n_s_TA_CDLHIKKAKEMOD; - PyObject *__pyx_n_s_TA_CDLHOMINGPIGEON; - PyObject *__pyx_n_s_TA_CDLIDENTICAL3CROWS; - PyObject *__pyx_n_s_TA_CDLINNECK; - PyObject *__pyx_n_s_TA_CDLINVERTEDHAMMER; - PyObject *__pyx_n_s_TA_CDLKICKING; - PyObject *__pyx_n_s_TA_CDLKICKINGBYLENGTH; - PyObject *__pyx_n_s_TA_CDLLADDERBOTTOM; - PyObject *__pyx_n_s_TA_CDLLONGLEGGEDDOJI; - PyObject *__pyx_n_s_TA_CDLLONGLINE; - PyObject *__pyx_n_s_TA_CDLMARUBOZU; - PyObject *__pyx_n_s_TA_CDLMATCHINGLOW; - PyObject *__pyx_n_s_TA_CDLMATHOLD; - PyObject *__pyx_n_s_TA_CDLMORNINGDOJISTAR; - PyObject *__pyx_n_s_TA_CDLMORNINGSTAR; - PyObject *__pyx_n_s_TA_CDLONNECK; - PyObject *__pyx_n_s_TA_CDLPIERCING; - PyObject *__pyx_n_s_TA_CDLRICKSHAWMAN; - PyObject *__pyx_n_s_TA_CDLRISEFALL3METHODS; - PyObject *__pyx_n_s_TA_CDLSEPARATINGLINES; - PyObject *__pyx_n_s_TA_CDLSHOOTINGSTAR; - PyObject *__pyx_n_s_TA_CDLSHORTLINE; - PyObject *__pyx_n_s_TA_CDLSPINNINGTOP; - PyObject *__pyx_n_s_TA_CDLSTALLEDPATTERN; - PyObject *__pyx_n_s_TA_CDLSTICKSANDWICH; - PyObject *__pyx_n_s_TA_CDLTAKURI; - PyObject *__pyx_n_s_TA_CDLTASUKIGAP; - PyObject *__pyx_n_s_TA_CDLTHRUSTING; - PyObject *__pyx_n_s_TA_CDLTRISTAR; - PyObject *__pyx_n_s_TA_CDLUNIQUE3RIVER; - PyObject *__pyx_n_s_TA_CDLUPSIDEGAP2CROWS; - PyObject *__pyx_n_s_TA_CDLXSIDEGAP3METHODS; - PyObject *__pyx_n_s_TA_CEIL; - PyObject *__pyx_n_s_TA_CMO; - PyObject *__pyx_n_s_TA_CORREL; - PyObject *__pyx_n_s_TA_COS; - PyObject *__pyx_n_s_TA_COSH; - PyObject *__pyx_n_s_TA_DEMA; - PyObject *__pyx_n_s_TA_DIV; - PyObject *__pyx_n_s_TA_DX; - PyObject *__pyx_n_s_TA_EMA; - PyObject *__pyx_n_s_TA_EXP; - PyObject *__pyx_n_s_TA_FLOOR; - PyObject *__pyx_n_s_TA_FUNCTION_NAMES; - PyObject *__pyx_n_s_TA_FUNC_FLAGS; - PyObject *__pyx_n_s_TA_FuncTableAlloc; - PyObject *__pyx_n_s_TA_FuncTableFree; - PyObject *__pyx_n_s_TA_GetFuncHandle; - PyObject *__pyx_n_s_TA_GetFuncInfo; - PyObject *__pyx_n_s_TA_GetInputParameterInfo; - PyObject *__pyx_n_s_TA_GetLookback; - PyObject *__pyx_n_s_TA_GetOptInputParameterInfo; - PyObject *__pyx_n_s_TA_GetOutputParameterInfo; - PyObject *__pyx_n_s_TA_GroupTableAlloc; - PyObject *__pyx_n_s_TA_GroupTableFree; - PyObject *__pyx_n_s_TA_HT_DCPERIOD; - PyObject *__pyx_n_s_TA_HT_DCPHASE; - PyObject *__pyx_n_s_TA_HT_PHASOR; - PyObject *__pyx_n_s_TA_HT_SINE; - PyObject *__pyx_n_s_TA_HT_TRENDLINE; - PyObject *__pyx_n_s_TA_HT_TRENDMODE; - PyObject *__pyx_n_s_TA_INPUT_FLAGS; - PyObject *__pyx_n_s_TA_Initialize; - PyObject *__pyx_n_s_TA_KAMA; - PyObject *__pyx_n_s_TA_LINEARREG; - PyObject *__pyx_n_s_TA_LINEARREG_ANGLE; - PyObject *__pyx_n_s_TA_LINEARREG_INTERCEPT; - PyObject *__pyx_n_s_TA_LINEARREG_SLOPE; - PyObject *__pyx_n_s_TA_LN; - PyObject *__pyx_n_s_TA_LOG10; - PyObject *__pyx_n_s_TA_MA; - PyObject *__pyx_n_s_TA_MACD; - PyObject *__pyx_n_s_TA_MACDEXT; - PyObject *__pyx_n_s_TA_MACDFIX; - PyObject *__pyx_n_s_TA_MAMA; - PyObject *__pyx_n_s_TA_MAVP; - PyObject *__pyx_n_s_TA_MAX; - PyObject *__pyx_n_s_TA_MAXINDEX; - PyObject *__pyx_n_s_TA_MEDPRICE; - PyObject *__pyx_n_s_TA_MFI; - PyObject *__pyx_n_s_TA_MIDPOINT; - PyObject *__pyx_n_s_TA_MIDPRICE; - PyObject *__pyx_n_s_TA_MIN; - PyObject *__pyx_n_s_TA_MININDEX; - PyObject *__pyx_n_s_TA_MINMAX; - PyObject *__pyx_n_s_TA_MINMAXINDEX; - PyObject *__pyx_n_s_TA_MINUS_DI; - PyObject *__pyx_n_s_TA_MINUS_DM; - PyObject *__pyx_n_s_TA_MOM; - PyObject *__pyx_n_s_TA_MULT; - PyObject *__pyx_n_s_TA_NATR; - PyObject *__pyx_n_s_TA_OBV; - PyObject *__pyx_n_s_TA_OUTPUT_FLAGS; - PyObject *__pyx_n_s_TA_PLUS_DI; - PyObject *__pyx_n_s_TA_PLUS_DM; - PyObject *__pyx_n_s_TA_PPO; - PyObject *__pyx_n_s_TA_ParamHolderAlloc; - PyObject *__pyx_n_s_TA_ParamHolderFree; - PyObject *__pyx_n_s_TA_ROC; - PyObject *__pyx_n_s_TA_ROCP; - PyObject *__pyx_n_s_TA_ROCR; - PyObject *__pyx_n_s_TA_ROCR100; - PyObject *__pyx_n_s_TA_RSI; - PyObject *__pyx_n_s_TA_RestoreCandleDefaultSettings; - PyObject *__pyx_n_s_TA_SAR; - PyObject *__pyx_n_s_TA_SAREXT; - PyObject *__pyx_n_s_TA_SIN; - PyObject *__pyx_n_s_TA_SINH; - PyObject *__pyx_n_s_TA_SMA; - PyObject *__pyx_n_s_TA_SQRT; - PyObject *__pyx_n_s_TA_STDDEV; - PyObject *__pyx_n_s_TA_STOCH; - PyObject *__pyx_n_s_TA_STOCHF; - PyObject *__pyx_n_s_TA_STOCHRSI; - PyObject *__pyx_n_s_TA_SUB; - PyObject *__pyx_n_s_TA_SUM; - PyObject *__pyx_n_s_TA_SetCandleSettings; - PyObject *__pyx_n_s_TA_SetCompatibility; - PyObject *__pyx_n_s_TA_SetOptInputParamInteger; - PyObject *__pyx_n_s_TA_SetOptInputParamReal; - PyObject *__pyx_n_s_TA_SetUnstablePeriod; - PyObject *__pyx_n_s_TA_Shutdown; - PyObject *__pyx_n_s_TA_T3; - PyObject *__pyx_n_s_TA_TAN; - PyObject *__pyx_n_s_TA_TANH; - PyObject *__pyx_n_s_TA_TEMA; - PyObject *__pyx_n_s_TA_TRANGE; - PyObject *__pyx_n_s_TA_TRIMA; - PyObject *__pyx_n_s_TA_TRIX; - PyObject *__pyx_n_s_TA_TSF; - PyObject *__pyx_n_s_TA_TYPPRICE; - PyObject *__pyx_n_s_TA_ULTOSC; - PyObject *__pyx_n_s_TA_VAR; - PyObject *__pyx_n_s_TA_WCLPRICE; - PyObject *__pyx_n_s_TA_WILLR; - PyObject *__pyx_n_s_TA_WMA; - PyObject *__pyx_n_s_TEMA; - PyObject *__pyx_n_s_TRANGE; - PyObject *__pyx_n_s_TRIMA; - PyObject *__pyx_n_s_TRIX; - PyObject *__pyx_n_s_TSF; - PyObject *__pyx_n_s_TYPPRICE; - PyObject *__pyx_kp_s_This_is_a_pythonic_wrapper_arou; - PyObject *__pyx_kp_s_Too_many_price_arguments_expecte; - PyObject *__pyx_kp_s_Triangular_Moving_Average; - PyObject *__pyx_kp_s_Triple_Exponential_Moving_Averag; - PyObject *__pyx_kp_s_Triple_Generalized_Double_Expone; - PyObject *__pyx_n_s_TypeError; - PyObject *__pyx_n_s_ULTOSC; - PyObject *__pyx_kp_s_Unknown_Error; - PyObject *__pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR; - PyObject *__pyx_n_s_VAR; - PyObject *__pyx_kp_s_Values_represent_a_lower_limit; - PyObject *__pyx_kp_s_Values_represent_an_upper_limit; - PyObject *__pyx_n_s_WCLPRICE; - PyObject *__pyx_n_s_WILLR; - PyObject *__pyx_n_s_WMA; - PyObject *__pyx_kp_s_Weighted_Moving_Average; - PyObject *__pyx_kp_s__10; - PyObject *__pyx_kp_s__11; - PyObject *__pyx_kp_s__12; - PyObject *__pyx_n_s__240; - PyObject *__pyx_kp_u__43; - PyObject *__pyx_n_s__503; - PyObject *__pyx_kp_s__6; - PyObject *__pyx_kp_s__7; - PyObject *__pyx_kp_s__9; - PyObject *__pyx_n_s_acceleration; - PyObject *__pyx_n_s_accelerationinitlong; - PyObject *__pyx_n_s_accelerationinitshort; - PyObject *__pyx_n_s_accelerationlong; - PyObject *__pyx_n_s_accelerationmaxlong; - PyObject *__pyx_n_s_accelerationmaxshort; - PyObject *__pyx_n_s_accelerationshort; - PyObject *__pyx_n_s_all; - PyObject *__pyx_kp_s_any_ndarray; - PyObject *__pyx_n_s_append; - PyObject *__pyx_n_s_arg; - PyObject *__pyx_n_s_args; - PyObject *__pyx_n_s_ascii; - PyObject *__pyx_n_s_astype; - PyObject *__pyx_n_s_asyncio_coroutines; - PyObject *__pyx_n_s_avgperiod; - PyObject *__pyx_n_s_b; - PyObject *__pyx_n_s_begidx; - PyObject *__pyx_n_s_bytes2str; - PyObject *__pyx_n_s_call; - PyObject *__pyx_n_s_call_function; - PyObject *__pyx_n_s_check_opt_input_value; - PyObject *__pyx_n_s_class_getitem; - PyObject *__pyx_n_s_cline_in_traceback; - PyObject *__pyx_n_s_clone; - PyObject *__pyx_n_s_close; - PyObject *__pyx_n_s_close_data; - PyObject *__pyx_n_s_collections; - PyObject *__pyx_n_s_column_stack; - PyObject *__pyx_n_s_columns; - PyObject *__pyx_n_s_copy; - PyObject *__pyx_n_s_decode; - PyObject *__pyx_n_s_default_value; - PyObject *__pyx_n_s_defaults; - PyObject *__pyx_n_s_dict; - PyObject *__pyx_n_s_display_name; - PyObject *__pyx_kp_s_display_name_s_group_s; - PyObject *__pyx_n_s_doc; - PyObject *__pyx_n_s_docs; - PyObject *__pyx_n_s_documentation; - PyObject *__pyx_n_s_empty; - PyObject *__pyx_n_s_endidx; - PyObject *__pyx_n_s_enumerate; - PyObject *__pyx_n_s_factor; - PyObject *__pyx_n_s_fastd_matype; - PyObject *__pyx_n_s_fastd_period; - PyObject *__pyx_n_s_fastk_period; - PyObject *__pyx_n_s_fastlimit; - PyObject *__pyx_n_s_fastmatype; - PyObject *__pyx_n_s_fastperiod; - PyObject *__pyx_n_s_flag; - PyObject *__pyx_n_s_flags; - PyObject *__pyx_n_s_flags_lookup_dict; - PyObject *__pyx_n_s_func_args; - PyObject *__pyx_n_s_func_info; - PyObject *__pyx_n_s_func_line; - PyObject *__pyx_n_s_func_object; - PyObject *__pyx_n_s_function_flags; - PyObject *__pyx_n_s_function_name; - PyObject *__pyx_n_s_functions; - PyObject *__pyx_n_s_get_defaults_and_docs; - PyObject *__pyx_n_s_get_flags; - PyObject *__pyx_n_s_get_input_arrays; - PyObject *__pyx_n_s_get_input_names; - PyObject *__pyx_n_s_get_opt_input_value; - PyObject *__pyx_n_s_get_parameters; - PyObject *__pyx_n_s_getitem; - PyObject *__pyx_n_s_group; - PyObject *__pyx_n_s_groups; - PyObject *__pyx_n_s_help; - PyObject *__pyx_n_s_high; - PyObject *__pyx_n_s_high_data; - PyObject *__pyx_n_s_holder; - PyObject *__pyx_n_s_i; - PyObject *__pyx_n_s_id; - PyObject *__pyx_n_s_idx; - PyObject *__pyx_n_s_import; - PyObject *__pyx_n_s_in; - PyObject *__pyx_n_s_index; - PyObject *__pyx_n_s_info; - PyObject *__pyx_n_s_init; - PyObject *__pyx_n_s_init_subclass; - PyObject *__pyx_n_s_initializing; - PyObject *__pyx_kp_s_input_array_has_wrong_dimensions; - PyObject *__pyx_kp_s_input_array_lengths_are_differen; - PyObject *__pyx_kp_s_input_array_type_is_not_double; - PyObject *__pyx_n_s_input_arrays; - PyObject *__pyx_kp_s_input_arrays_2; - PyObject *__pyx_kp_s_input_arrays_parameter_missing_r; - PyObject *__pyx_n_s_input_name; - PyObject *__pyx_n_s_input_names; - PyObject *__pyx_n_s_input_price_series_names; - PyObject *__pyx_n_s_input_price_series_names_2; - PyObject *__pyx_n_s_integer; - PyObject *__pyx_kp_s_integer_values_are_100_0_or_100; - PyObject *__pyx_n_s_is_coroutine; - PyObject *__pyx_n_s_is_empty; - PyObject *__pyx_n_s_items; - PyObject *__pyx_n_s_join; - PyObject *__pyx_n_s_key; - PyObject *__pyx_n_s_keys; - PyObject *__pyx_n_s_kwargs; - PyObject *__pyx_n_s_length; - PyObject *__pyx_n_s_local; - PyObject *__pyx_n_s_local_2; - PyObject *__pyx_n_s_log; - PyObject *__pyx_n_s_lookback; - PyObject *__pyx_n_s_lookup; - PyObject *__pyx_n_s_low; - PyObject *__pyx_n_s_low_data; - PyObject *__pyx_n_s_lower; - PyObject *__pyx_n_s_main; - PyObject *__pyx_n_s_math; - PyObject *__pyx_n_s_matype; - PyObject *__pyx_n_s_max; - PyObject *__pyx_n_s_max_int; - PyObject *__pyx_n_s_maximum; - PyObject *__pyx_n_s_maxperiod; - PyObject *__pyx_n_s_metaclass; - PyObject *__pyx_n_s_min; - PyObject *__pyx_n_s_min_int; - PyObject *__pyx_n_s_minperiod; - PyObject *__pyx_n_s_missing; - PyObject *__pyx_n_s_missing_keys; - PyObject *__pyx_n_s_module; - PyObject *__pyx_n_s_mro_entries; - PyObject *__pyx_n_s_msg; - PyObject *__pyx_n_s_n; - PyObject *__pyx_n_s_name; - PyObject *__pyx_n_s_name_2; - PyObject *__pyx_n_s_nan; - PyObject *__pyx_n_s_nbdev; - PyObject *__pyx_n_s_nbdevdn; - PyObject *__pyx_n_s_nbdevup; - PyObject *__pyx_n_s_no_existing_input_arrays; - PyObject *__pyx_n_s_num_inputs; - PyObject *__pyx_n_s_num_opt_inputs; - PyObject *__pyx_n_s_num_outputs; - PyObject *__pyx_n_s_numpy; - PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; - PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; - PyObject *__pyx_n_s_object; - PyObject *__pyx_n_s_offsetonreverse; - PyObject *__pyx_n_s_open; - PyObject *__pyx_n_s_openInterest; - PyObject *__pyx_n_s_open_data; - PyObject *__pyx_n_s_optIn; - PyObject *__pyx_n_s_opt_input; - PyObject *__pyx_n_s_opt_input_values; - PyObject *__pyx_n_s_opt_inputs; - PyObject *__pyx_n_s_ordereddict; - PyObject *__pyx_n_s_out; - PyObject *__pyx_n_s_outaroondown; - PyObject *__pyx_n_s_outaroonup; - PyObject *__pyx_n_s_outbegidx; - PyObject *__pyx_n_s_outfama; - PyObject *__pyx_n_s_outfastd; - PyObject *__pyx_n_s_outfastk; - PyObject *__pyx_n_s_outinphase; - PyObject *__pyx_n_s_outinteger; - PyObject *__pyx_n_s_outinteger_data; - PyObject *__pyx_n_s_outleadsine; - PyObject *__pyx_n_s_outmacd; - PyObject *__pyx_n_s_outmacdhist; - PyObject *__pyx_n_s_outmacdsignal; - PyObject *__pyx_n_s_outmama; - PyObject *__pyx_n_s_outmax; - PyObject *__pyx_n_s_outmaxidx; - PyObject *__pyx_n_s_outmaxidx_data; - PyObject *__pyx_n_s_outmin; - PyObject *__pyx_n_s_outminidx; - PyObject *__pyx_n_s_outminidx_data; - PyObject *__pyx_n_s_outnbelement; - PyObject *__pyx_n_s_output; - PyObject *__pyx_n_s_output_flags; - PyObject *__pyx_n_s_output_name; - PyObject *__pyx_n_s_output_names; - PyObject *__pyx_n_s_outputs; - PyObject *__pyx_n_s_outputs_valid; - PyObject *__pyx_n_s_outquadrature; - PyObject *__pyx_n_s_outreal; - PyObject *__pyx_n_s_outreallowerband; - PyObject *__pyx_n_s_outrealmiddleband; - PyObject *__pyx_n_s_outrealupperband; - PyObject *__pyx_n_s_outsine; - PyObject *__pyx_n_s_outslowd; - PyObject *__pyx_n_s_outslowk; - PyObject *__pyx_n_s_pandas; - PyObject *__pyx_n_s_param; - PyObject *__pyx_n_s_param_name; - PyObject *__pyx_n_s_parameters; - PyObject *__pyx_n_s_params; - PyObject *__pyx_n_s_penetration; - PyObject *__pyx_n_s_period; - PyObject *__pyx_n_s_periods; - PyObject *__pyx_n_s_periods_data; - PyObject *__pyx_n_s_polars; - PyObject *__pyx_n_s_pop; - PyObject *__pyx_n_s_prepare; - PyObject *__pyx_n_s_price; - PyObject *__pyx_n_s_price0; - PyObject *__pyx_n_s_price1; - PyObject *__pyx_n_s_price_series; - PyObject *__pyx_n_s_price_series_name_values; - PyObject *__pyx_n_s_prices; - PyObject *__pyx_n_s_property; - PyObject *__pyx_n_s_qualname; - PyObject *__pyx_n_s_range; - PyObject *__pyx_n_s_rangetype; - PyObject *__pyx_n_s_real; - PyObject *__pyx_n_s_real0; - PyObject *__pyx_n_s_real0_data; - PyObject *__pyx_n_s_real1; - PyObject *__pyx_n_s_real1_data; - PyObject *__pyx_n_s_real_data; - PyObject *__pyx_n_s_replace; - PyObject *__pyx_n_s_repr; - PyObject *__pyx_n_s_results; - PyObject *__pyx_n_s_ret; - PyObject *__pyx_n_s_retCode; - PyObject *__pyx_n_s_ret_code; - PyObject *__pyx_n_s_run; - PyObject *__pyx_n_s_s; - PyObject *__pyx_kp_s_s_2; - PyObject *__pyx_kp_s_s_3; - PyObject *__pyx_kp_s_s_4; - PyObject *__pyx_kp_s_s_function_failed_with_error_co; - PyObject *__pyx_kp_s_s_s; - PyObject *__pyx_kp_s_s_s_2; - PyObject *__pyx_n_s_schema; - PyObject *__pyx_n_s_self; - PyObject *__pyx_n_s_series; - PyObject *__pyx_n_s_set_function_args; - PyObject *__pyx_n_s_set_input_arrays; - PyObject *__pyx_n_s_set_input_names; - PyObject *__pyx_n_s_set_name; - PyObject *__pyx_n_s_set_parameters; - PyObject *__pyx_n_s_settingtype; - PyObject *__pyx_n_s_signalmatype; - PyObject *__pyx_n_s_signalperiod; - PyObject *__pyx_n_s_skip_first; - PyObject *__pyx_n_s_slowd_matype; - PyObject *__pyx_n_s_slowd_period; - PyObject *__pyx_n_s_slowk_matype; - PyObject *__pyx_n_s_slowk_period; - PyObject *__pyx_n_s_slowlimit; - PyObject *__pyx_n_s_slowmatype; - PyObject *__pyx_n_s_slowperiod; - PyObject *__pyx_n_s_spec; - PyObject *__pyx_n_s_startvalue; - PyObject *__pyx_n_s_str; - PyObject *__pyx_n_s_str2bytes; - PyObject *__pyx_n_s_stream_ACOS; - PyObject *__pyx_n_s_stream_AD; - PyObject *__pyx_n_s_stream_ADD; - PyObject *__pyx_n_s_stream_ADOSC; - PyObject *__pyx_n_s_stream_ADX; - PyObject *__pyx_n_s_stream_ADXR; - PyObject *__pyx_n_s_stream_APO; - PyObject *__pyx_n_s_stream_AROON; - PyObject *__pyx_n_s_stream_AROONOSC; - PyObject *__pyx_n_s_stream_ASIN; - PyObject *__pyx_n_s_stream_ATAN; - PyObject *__pyx_n_s_stream_ATR; - PyObject *__pyx_n_s_stream_AVGPRICE; - PyObject *__pyx_n_s_stream_BBANDS; - PyObject *__pyx_n_s_stream_BETA; - PyObject *__pyx_n_s_stream_BOP; - PyObject *__pyx_n_s_stream_CCI; - PyObject *__pyx_n_s_stream_CDL2CROWS; - PyObject *__pyx_n_s_stream_CDL3BLACKCROWS; - PyObject *__pyx_n_s_stream_CDL3INSIDE; - PyObject *__pyx_n_s_stream_CDL3LINESTRIKE; - PyObject *__pyx_n_s_stream_CDL3OUTSIDE; - PyObject *__pyx_n_s_stream_CDL3STARSINSOUTH; - PyObject *__pyx_n_s_stream_CDL3WHITESOLDIERS; - PyObject *__pyx_n_s_stream_CDLABANDONEDBABY; - PyObject *__pyx_n_s_stream_CDLADVANCEBLOCK; - PyObject *__pyx_n_s_stream_CDLBELTHOLD; - PyObject *__pyx_n_s_stream_CDLBREAKAWAY; - PyObject *__pyx_n_s_stream_CDLCLOSINGMARUBOZU; - PyObject *__pyx_n_s_stream_CDLCONCEALBABYSWALL; - PyObject *__pyx_n_s_stream_CDLCOUNTERATTACK; - PyObject *__pyx_n_s_stream_CDLDARKCLOUDCOVER; - PyObject *__pyx_n_s_stream_CDLDOJI; - PyObject *__pyx_n_s_stream_CDLDOJISTAR; - PyObject *__pyx_n_s_stream_CDLDRAGONFLYDOJI; - PyObject *__pyx_n_s_stream_CDLENGULFING; - PyObject *__pyx_n_s_stream_CDLEVENINGDOJISTAR; - PyObject *__pyx_n_s_stream_CDLEVENINGSTAR; - PyObject *__pyx_n_s_stream_CDLGAPSIDESIDEWHITE; - PyObject *__pyx_n_s_stream_CDLGRAVESTONEDOJI; - PyObject *__pyx_n_s_stream_CDLHAMMER; - PyObject *__pyx_n_s_stream_CDLHANGINGMAN; - PyObject *__pyx_n_s_stream_CDLHARAMI; - PyObject *__pyx_n_s_stream_CDLHARAMICROSS; - PyObject *__pyx_n_s_stream_CDLHIGHWAVE; - PyObject *__pyx_n_s_stream_CDLHIKKAKE; - PyObject *__pyx_n_s_stream_CDLHIKKAKEMOD; - PyObject *__pyx_n_s_stream_CDLHOMINGPIGEON; - PyObject *__pyx_n_s_stream_CDLIDENTICAL3CROWS; - PyObject *__pyx_n_s_stream_CDLINNECK; - PyObject *__pyx_n_s_stream_CDLINVERTEDHAMMER; - PyObject *__pyx_n_s_stream_CDLKICKING; - PyObject *__pyx_n_s_stream_CDLKICKINGBYLENGTH; - PyObject *__pyx_n_s_stream_CDLLADDERBOTTOM; - PyObject *__pyx_n_s_stream_CDLLONGLEGGEDDOJI; - PyObject *__pyx_n_s_stream_CDLLONGLINE; - PyObject *__pyx_n_s_stream_CDLMARUBOZU; - PyObject *__pyx_n_s_stream_CDLMATCHINGLOW; - PyObject *__pyx_n_s_stream_CDLMATHOLD; - PyObject *__pyx_n_s_stream_CDLMORNINGDOJISTAR; - PyObject *__pyx_n_s_stream_CDLMORNINGSTAR; - PyObject *__pyx_n_s_stream_CDLONNECK; - PyObject *__pyx_n_s_stream_CDLPIERCING; - PyObject *__pyx_n_s_stream_CDLRICKSHAWMAN; - PyObject *__pyx_n_s_stream_CDLRISEFALL3METHODS; - PyObject *__pyx_n_s_stream_CDLSEPARATINGLINES; - PyObject *__pyx_n_s_stream_CDLSHOOTINGSTAR; - PyObject *__pyx_n_s_stream_CDLSHORTLINE; - PyObject *__pyx_n_s_stream_CDLSPINNINGTOP; - PyObject *__pyx_n_s_stream_CDLSTALLEDPATTERN; - PyObject *__pyx_n_s_stream_CDLSTICKSANDWICH; - PyObject *__pyx_n_s_stream_CDLTAKURI; - PyObject *__pyx_n_s_stream_CDLTASUKIGAP; - PyObject *__pyx_n_s_stream_CDLTHRUSTING; - PyObject *__pyx_n_s_stream_CDLTRISTAR; - PyObject *__pyx_n_s_stream_CDLUNIQUE3RIVER; - PyObject *__pyx_n_s_stream_CDLUPSIDEGAP2CROWS; - PyObject *__pyx_n_s_stream_CDLXSIDEGAP3METHODS; - PyObject *__pyx_n_s_stream_CEIL; - PyObject *__pyx_n_s_stream_CMO; - PyObject *__pyx_n_s_stream_CORREL; - PyObject *__pyx_n_s_stream_COS; - PyObject *__pyx_n_s_stream_COSH; - PyObject *__pyx_n_s_stream_DEMA; - PyObject *__pyx_n_s_stream_DIV; - PyObject *__pyx_n_s_stream_DX; - PyObject *__pyx_n_s_stream_EMA; - PyObject *__pyx_n_s_stream_EXP; - PyObject *__pyx_n_s_stream_FLOOR; - PyObject *__pyx_n_s_stream_HT_DCPERIOD; - PyObject *__pyx_n_s_stream_HT_DCPHASE; - PyObject *__pyx_n_s_stream_HT_PHASOR; - PyObject *__pyx_n_s_stream_HT_SINE; - PyObject *__pyx_n_s_stream_HT_TRENDLINE; - PyObject *__pyx_n_s_stream_HT_TRENDMODE; - PyObject *__pyx_n_s_stream_KAMA; - PyObject *__pyx_n_s_stream_LINEARREG; - PyObject *__pyx_n_s_stream_LINEARREG_ANGLE; - PyObject *__pyx_n_s_stream_LINEARREG_INTERCEPT; - PyObject *__pyx_n_s_stream_LINEARREG_SLOPE; - PyObject *__pyx_n_s_stream_LN; - PyObject *__pyx_n_s_stream_LOG10; - PyObject *__pyx_n_s_stream_MA; - PyObject *__pyx_n_s_stream_MACD; - PyObject *__pyx_n_s_stream_MACDEXT; - PyObject *__pyx_n_s_stream_MACDFIX; - PyObject *__pyx_n_s_stream_MAMA; - PyObject *__pyx_n_s_stream_MAVP; - PyObject *__pyx_n_s_stream_MAX; - PyObject *__pyx_n_s_stream_MAXINDEX; - PyObject *__pyx_n_s_stream_MEDPRICE; - PyObject *__pyx_n_s_stream_MFI; - PyObject *__pyx_n_s_stream_MIDPOINT; - PyObject *__pyx_n_s_stream_MIDPRICE; - PyObject *__pyx_n_s_stream_MIN; - PyObject *__pyx_n_s_stream_MININDEX; - PyObject *__pyx_n_s_stream_MINMAX; - PyObject *__pyx_n_s_stream_MINMAXINDEX; - PyObject *__pyx_n_s_stream_MINUS_DI; - PyObject *__pyx_n_s_stream_MINUS_DM; - PyObject *__pyx_n_s_stream_MOM; - PyObject *__pyx_n_s_stream_MULT; - PyObject *__pyx_n_s_stream_NATR; - PyObject *__pyx_n_s_stream_OBV; - PyObject *__pyx_n_s_stream_PLUS_DI; - PyObject *__pyx_n_s_stream_PLUS_DM; - PyObject *__pyx_n_s_stream_PPO; - PyObject *__pyx_n_s_stream_ROC; - PyObject *__pyx_n_s_stream_ROCP; - PyObject *__pyx_n_s_stream_ROCR; - PyObject *__pyx_n_s_stream_ROCR100; - PyObject *__pyx_n_s_stream_RSI; - PyObject *__pyx_n_s_stream_SAR; - PyObject *__pyx_n_s_stream_SAREXT; - PyObject *__pyx_n_s_stream_SIN; - PyObject *__pyx_n_s_stream_SINH; - PyObject *__pyx_n_s_stream_SMA; - PyObject *__pyx_n_s_stream_SQRT; - PyObject *__pyx_n_s_stream_STDDEV; - PyObject *__pyx_n_s_stream_STOCH; - PyObject *__pyx_n_s_stream_STOCHF; - PyObject *__pyx_n_s_stream_STOCHRSI; - PyObject *__pyx_n_s_stream_SUB; - PyObject *__pyx_n_s_stream_SUM; - PyObject *__pyx_n_s_stream_T3; - PyObject *__pyx_n_s_stream_TAN; - PyObject *__pyx_n_s_stream_TANH; - PyObject *__pyx_n_s_stream_TEMA; - PyObject *__pyx_n_s_stream_TRANGE; - PyObject *__pyx_n_s_stream_TRIMA; - PyObject *__pyx_n_s_stream_TRIX; - PyObject *__pyx_n_s_stream_TSF; - PyObject *__pyx_n_s_stream_TYPPRICE; - PyObject *__pyx_n_s_stream_ULTOSC; - PyObject *__pyx_n_s_stream_VAR; - PyObject *__pyx_n_s_stream_WCLPRICE; - PyObject *__pyx_n_s_stream_WILLR; - PyObject *__pyx_n_s_stream_WMA; - PyObject *__pyx_kp_s_stream__s; - PyObject *__pyx_n_s_super; - PyObject *__pyx_n_s_sys; - PyObject *__pyx_n_s_ta_check_success; - PyObject *__pyx_n_s_ta_func_unst_ids; - PyObject *__pyx_n_s_ta_getFuncInfo; - PyObject *__pyx_n_s_ta_getFuncTable; - PyObject *__pyx_n_s_ta_getGroupTable; - PyObject *__pyx_n_s_ta_getInputParameterInfo; - PyObject *__pyx_n_s_ta_getOptInputParameterInfo; - PyObject *__pyx_n_s_ta_getOutputParameterInfo; - PyObject *__pyx_n_s_ta_get_compatibility; - PyObject *__pyx_n_s_ta_get_unstable_period; - PyObject *__pyx_n_s_ta_initialize; - PyObject *__pyx_n_s_ta_restore_candle_default_setti; - PyObject *__pyx_n_s_ta_set_candle_settings; - PyObject *__pyx_n_s_ta_set_compatibility; - PyObject *__pyx_n_s_ta_set_unstable_period; - PyObject *__pyx_n_s_ta_shutdown; - PyObject *__pyx_n_s_ta_version; - PyObject *__pyx_n_s_table; - PyObject *__pyx_kp_s_talib__abstract_pxi; - PyObject *__pyx_kp_s_talib__common_pxi; - PyObject *__pyx_kp_s_talib__func_pxi; - PyObject *__pyx_kp_s_talib__stream_pxi; - PyObject *__pyx_n_s_talib__ta_lib; - PyObject *__pyx_n_s_test; - PyObject *__pyx_n_s_threading; - PyObject *__pyx_n_s_timeStamp; - PyObject *__pyx_n_s_timeperiod; - PyObject *__pyx_n_s_timeperiod1; - PyObject *__pyx_n_s_timeperiod2; - PyObject *__pyx_n_s_timeperiod3; - PyObject *__pyx_n_s_to_numpy; - PyObject *__pyx_n_s_type; - PyObject *__pyx_n_s_type_2; - PyObject *__pyx_n_s_unicode; - PyObject *__pyx_n_s_update; - PyObject *__pyx_n_s_update_info; - PyObject *__pyx_n_s_upper; - PyObject *__pyx_n_s_value; - PyObject *__pyx_n_s_value_range; - PyObject *__pyx_n_s_values; - PyObject *__pyx_n_s_version; - PyObject *__pyx_n_s_vfactor; - PyObject *__pyx_n_s_volume; - PyObject *__pyx_n_s_volume_data; - PyObject *__pyx_n_s_xrange; - PyObject *__pyx_int_0; - PyObject *__pyx_int_1; - PyObject *__pyx_int_2; - PyObject *__pyx_int_3; - PyObject *__pyx_int_4; - PyObject *__pyx_int_8; - PyObject *__pyx_int_9; - PyObject *__pyx_int_12; - PyObject *__pyx_int_16; - PyObject *__pyx_int_32; - PyObject *__pyx_int_64; - PyObject *__pyx_int_128; - PyObject *__pyx_int_256; - PyObject *__pyx_int_512; - PyObject *__pyx_int_1024; - PyObject *__pyx_int_2048; - PyObject *__pyx_int_4096; - PyObject *__pyx_int_16777216; - PyObject *__pyx_int_67108864; - PyObject *__pyx_int_134217728; - PyObject *__pyx_int_268435456; - PyObject *__pyx_int_neg_1; - PyObject *__pyx_tuple_; - PyObject *__pyx_tuple__2; - PyObject *__pyx_tuple__3; - PyObject *__pyx_tuple__4; - PyObject *__pyx_tuple__5; - PyObject *__pyx_tuple__8; - PyObject *__pyx_tuple__13; - PyObject *__pyx_tuple__15; - PyObject *__pyx_tuple__18; - PyObject *__pyx_tuple__19; - PyObject *__pyx_tuple__20; - PyObject *__pyx_tuple__21; - PyObject *__pyx_tuple__23; - PyObject *__pyx_tuple__25; - PyObject *__pyx_tuple__27; - PyObject *__pyx_tuple__29; - PyObject *__pyx_tuple__31; - PyObject *__pyx_tuple__33; - PyObject *__pyx_tuple__34; - PyObject *__pyx_tuple__35; - PyObject *__pyx_tuple__36; - PyObject *__pyx_tuple__37; - PyObject *__pyx_tuple__38; - PyObject *__pyx_tuple__39; - PyObject *__pyx_tuple__41; - PyObject *__pyx_tuple__44; - PyObject *__pyx_tuple__46; - PyObject *__pyx_tuple__48; - PyObject *__pyx_tuple__50; - PyObject *__pyx_tuple__52; - PyObject *__pyx_tuple__55; - PyObject *__pyx_tuple__57; - PyObject *__pyx_tuple__59; - PyObject *__pyx_tuple__64; - PyObject *__pyx_tuple__66; - PyObject *__pyx_tuple__68; - PyObject *__pyx_tuple__72; - PyObject *__pyx_tuple__80; - PyObject *__pyx_tuple__136; - PyObject *__pyx_tuple__149; - PyObject *__pyx_tuple__151; - PyObject *__pyx_tuple__154; - PyObject *__pyx_tuple__163; - PyObject *__pyx_tuple__165; - PyObject *__pyx_tuple__167; - PyObject *__pyx_tuple__169; - PyObject *__pyx_tuple__171; - PyObject *__pyx_tuple__173; - PyObject *__pyx_tuple__176; - PyObject *__pyx_tuple__178; - PyObject *__pyx_tuple__180; - PyObject *__pyx_tuple__186; - PyObject *__pyx_tuple__188; - PyObject *__pyx_tuple__195; - PyObject *__pyx_tuple__205; - PyObject *__pyx_tuple__207; - PyObject *__pyx_tuple__213; - PyObject *__pyx_tuple__215; - PyObject *__pyx_tuple__217; - PyObject *__pyx_tuple__219; - PyObject *__pyx_tuple__223; - PyObject *__pyx_tuple__228; - PyObject *__pyx_tuple__234; - PyObject *__pyx_tuple__241; - PyObject *__pyx_tuple__243; - PyObject *__pyx_tuple__247; - PyObject *__pyx_tuple__248; - PyObject *__pyx_tuple__249; - PyObject *__pyx_tuple__251; - PyObject *__pyx_tuple__256; - PyObject *__pyx_tuple__258; - PyObject *__pyx_tuple__260; - PyObject *__pyx_tuple__262; - PyObject *__pyx_tuple__264; - PyObject *__pyx_tuple__266; - PyObject *__pyx_tuple__268; - PyObject *__pyx_tuple__269; - PyObject *__pyx_tuple__271; - PyObject *__pyx_tuple__273; - PyObject *__pyx_tuple__275; - PyObject *__pyx_tuple__277; - PyObject *__pyx_tuple__279; - PyObject *__pyx_tuple__281; - PyObject *__pyx_tuple__283; - PyObject *__pyx_tuple__285; - PyObject *__pyx_tuple__287; - PyObject *__pyx_tuple__292; - PyObject *__pyx_tuple__294; - PyObject *__pyx_tuple__296; - PyObject *__pyx_tuple__298; - PyObject *__pyx_tuple__300; - PyObject *__pyx_tuple__302; - PyObject *__pyx_tuple__305; - PyObject *__pyx_tuple__307; - PyObject *__pyx_tuple__309; - PyObject *__pyx_tuple__311; - PyObject *__pyx_tuple__313; - PyObject *__pyx_tuple__315; - PyObject *__pyx_tuple__318; - PyObject *__pyx_tuple__320; - PyObject *__pyx_tuple__322; - PyObject *__pyx_tuple__327; - PyObject *__pyx_tuple__329; - PyObject *__pyx_tuple__331; - PyObject *__pyx_tuple__335; - PyObject *__pyx_tuple__343; - PyObject *__pyx_tuple__399; - PyObject *__pyx_tuple__412; - PyObject *__pyx_tuple__414; - PyObject *__pyx_tuple__417; - PyObject *__pyx_tuple__426; - PyObject *__pyx_tuple__428; - PyObject *__pyx_tuple__430; - PyObject *__pyx_tuple__432; - PyObject *__pyx_tuple__434; - PyObject *__pyx_tuple__436; - PyObject *__pyx_tuple__439; - PyObject *__pyx_tuple__441; - PyObject *__pyx_tuple__443; - PyObject *__pyx_tuple__449; - PyObject *__pyx_tuple__451; - PyObject *__pyx_tuple__458; - PyObject *__pyx_tuple__468; - PyObject *__pyx_tuple__470; - PyObject *__pyx_tuple__476; - PyObject *__pyx_tuple__478; - PyObject *__pyx_tuple__480; - PyObject *__pyx_tuple__482; - PyObject *__pyx_tuple__486; - PyObject *__pyx_tuple__491; - PyObject *__pyx_tuple__497; - PyObject *__pyx_codeobj__14; - PyObject *__pyx_codeobj__16; - PyObject *__pyx_codeobj__17; - PyObject *__pyx_codeobj__22; - PyObject *__pyx_codeobj__24; - PyObject *__pyx_codeobj__26; - PyObject *__pyx_codeobj__28; - PyObject *__pyx_codeobj__30; - PyObject *__pyx_codeobj__32; - PyObject *__pyx_codeobj__40; - PyObject *__pyx_codeobj__42; - PyObject *__pyx_codeobj__45; - PyObject *__pyx_codeobj__47; - PyObject *__pyx_codeobj__49; - PyObject *__pyx_codeobj__51; - PyObject *__pyx_codeobj__53; - PyObject *__pyx_codeobj__54; - PyObject *__pyx_codeobj__56; - PyObject *__pyx_codeobj__58; - PyObject *__pyx_codeobj__60; - PyObject *__pyx_codeobj__61; - PyObject *__pyx_codeobj__62; - PyObject *__pyx_codeobj__63; - PyObject *__pyx_codeobj__65; - PyObject *__pyx_codeobj__67; - PyObject *__pyx_codeobj__69; - PyObject *__pyx_codeobj__70; - PyObject *__pyx_codeobj__71; - PyObject *__pyx_codeobj__73; - PyObject *__pyx_codeobj__74; - PyObject *__pyx_codeobj__75; - PyObject *__pyx_codeobj__76; - PyObject *__pyx_codeobj__77; - PyObject *__pyx_codeobj__78; - PyObject *__pyx_codeobj__79; - PyObject *__pyx_codeobj__81; - PyObject *__pyx_codeobj__82; - PyObject *__pyx_codeobj__83; - PyObject *__pyx_codeobj__84; - PyObject *__pyx_codeobj__85; - PyObject *__pyx_codeobj__86; - PyObject *__pyx_codeobj__87; - PyObject *__pyx_codeobj__88; - PyObject *__pyx_codeobj__89; - PyObject *__pyx_codeobj__90; - PyObject *__pyx_codeobj__91; - PyObject *__pyx_codeobj__92; - PyObject *__pyx_codeobj__93; - PyObject *__pyx_codeobj__94; - PyObject *__pyx_codeobj__95; - PyObject *__pyx_codeobj__96; - PyObject *__pyx_codeobj__97; - PyObject *__pyx_codeobj__98; - PyObject *__pyx_codeobj__99; - PyObject *__pyx_codeobj__100; - PyObject *__pyx_codeobj__101; - PyObject *__pyx_codeobj__102; - PyObject *__pyx_codeobj__103; - PyObject *__pyx_codeobj__104; - PyObject *__pyx_codeobj__105; - PyObject *__pyx_codeobj__106; - PyObject *__pyx_codeobj__107; - PyObject *__pyx_codeobj__108; - PyObject *__pyx_codeobj__109; - PyObject *__pyx_codeobj__110; - PyObject *__pyx_codeobj__111; - PyObject *__pyx_codeobj__112; - PyObject *__pyx_codeobj__113; - PyObject *__pyx_codeobj__114; - PyObject *__pyx_codeobj__115; - PyObject *__pyx_codeobj__116; - PyObject *__pyx_codeobj__117; - PyObject *__pyx_codeobj__118; - PyObject *__pyx_codeobj__119; - PyObject *__pyx_codeobj__120; - PyObject *__pyx_codeobj__121; - PyObject *__pyx_codeobj__122; - PyObject *__pyx_codeobj__123; - PyObject *__pyx_codeobj__124; - PyObject *__pyx_codeobj__125; - PyObject *__pyx_codeobj__126; - PyObject *__pyx_codeobj__127; - PyObject *__pyx_codeobj__128; - PyObject *__pyx_codeobj__129; - PyObject *__pyx_codeobj__130; - PyObject *__pyx_codeobj__131; - PyObject *__pyx_codeobj__132; - PyObject *__pyx_codeobj__133; - PyObject *__pyx_codeobj__134; - PyObject *__pyx_codeobj__135; - PyObject *__pyx_codeobj__137; - PyObject *__pyx_codeobj__138; - PyObject *__pyx_codeobj__139; - PyObject *__pyx_codeobj__140; - PyObject *__pyx_codeobj__141; - PyObject *__pyx_codeobj__142; - PyObject *__pyx_codeobj__143; - PyObject *__pyx_codeobj__144; - PyObject *__pyx_codeobj__145; - PyObject *__pyx_codeobj__146; - PyObject *__pyx_codeobj__147; - PyObject *__pyx_codeobj__148; - PyObject *__pyx_codeobj__150; - PyObject *__pyx_codeobj__152; - PyObject *__pyx_codeobj__153; - PyObject *__pyx_codeobj__155; - PyObject *__pyx_codeobj__156; - PyObject *__pyx_codeobj__157; - PyObject *__pyx_codeobj__158; - PyObject *__pyx_codeobj__159; - PyObject *__pyx_codeobj__160; - PyObject *__pyx_codeobj__161; - PyObject *__pyx_codeobj__162; - PyObject *__pyx_codeobj__164; - PyObject *__pyx_codeobj__166; - PyObject *__pyx_codeobj__168; - PyObject *__pyx_codeobj__170; - PyObject *__pyx_codeobj__172; - PyObject *__pyx_codeobj__174; - PyObject *__pyx_codeobj__175; - PyObject *__pyx_codeobj__177; - PyObject *__pyx_codeobj__179; - PyObject *__pyx_codeobj__181; - PyObject *__pyx_codeobj__182; - PyObject *__pyx_codeobj__183; - PyObject *__pyx_codeobj__184; - PyObject *__pyx_codeobj__185; - PyObject *__pyx_codeobj__187; - PyObject *__pyx_codeobj__189; - PyObject *__pyx_codeobj__190; - PyObject *__pyx_codeobj__191; - PyObject *__pyx_codeobj__192; - PyObject *__pyx_codeobj__193; - PyObject *__pyx_codeobj__194; - PyObject *__pyx_codeobj__196; - PyObject *__pyx_codeobj__197; - PyObject *__pyx_codeobj__198; - PyObject *__pyx_codeobj__199; - PyObject *__pyx_codeobj__200; - PyObject *__pyx_codeobj__201; - PyObject *__pyx_codeobj__202; - PyObject *__pyx_codeobj__203; - PyObject *__pyx_codeobj__204; - PyObject *__pyx_codeobj__206; - PyObject *__pyx_codeobj__208; - PyObject *__pyx_codeobj__209; - PyObject *__pyx_codeobj__210; - PyObject *__pyx_codeobj__211; - PyObject *__pyx_codeobj__212; - PyObject *__pyx_codeobj__214; - PyObject *__pyx_codeobj__216; - PyObject *__pyx_codeobj__218; - PyObject *__pyx_codeobj__220; - PyObject *__pyx_codeobj__221; - PyObject *__pyx_codeobj__222; - PyObject *__pyx_codeobj__224; - PyObject *__pyx_codeobj__225; - PyObject *__pyx_codeobj__226; - PyObject *__pyx_codeobj__227; - PyObject *__pyx_codeobj__229; - PyObject *__pyx_codeobj__230; - PyObject *__pyx_codeobj__231; - PyObject *__pyx_codeobj__232; - PyObject *__pyx_codeobj__233; - PyObject *__pyx_codeobj__235; - PyObject *__pyx_codeobj__236; - PyObject *__pyx_codeobj__237; - PyObject *__pyx_codeobj__238; - PyObject *__pyx_codeobj__239; - PyObject *__pyx_codeobj__242; - PyObject *__pyx_codeobj__244; - PyObject *__pyx_codeobj__245; - PyObject *__pyx_codeobj__246; - PyObject *__pyx_codeobj__250; - PyObject *__pyx_codeobj__252; - PyObject *__pyx_codeobj__253; - PyObject *__pyx_codeobj__254; - PyObject *__pyx_codeobj__255; - PyObject *__pyx_codeobj__257; - PyObject *__pyx_codeobj__259; - PyObject *__pyx_codeobj__261; - PyObject *__pyx_codeobj__263; - PyObject *__pyx_codeobj__265; - PyObject *__pyx_codeobj__267; - PyObject *__pyx_codeobj__270; - PyObject *__pyx_codeobj__272; - PyObject *__pyx_codeobj__274; - PyObject *__pyx_codeobj__276; - PyObject *__pyx_codeobj__278; - PyObject *__pyx_codeobj__280; - PyObject *__pyx_codeobj__282; - PyObject *__pyx_codeobj__284; - PyObject *__pyx_codeobj__286; - PyObject *__pyx_codeobj__288; - PyObject *__pyx_codeobj__289; - PyObject *__pyx_codeobj__290; - PyObject *__pyx_codeobj__291; - PyObject *__pyx_codeobj__293; - PyObject *__pyx_codeobj__295; - PyObject *__pyx_codeobj__297; - PyObject *__pyx_codeobj__299; - PyObject *__pyx_codeobj__301; - PyObject *__pyx_codeobj__303; - PyObject *__pyx_codeobj__304; - PyObject *__pyx_codeobj__306; - PyObject *__pyx_codeobj__308; - PyObject *__pyx_codeobj__310; - PyObject *__pyx_codeobj__312; - PyObject *__pyx_codeobj__314; - PyObject *__pyx_codeobj__316; - PyObject *__pyx_codeobj__317; - PyObject *__pyx_codeobj__319; - PyObject *__pyx_codeobj__321; - PyObject *__pyx_codeobj__323; - PyObject *__pyx_codeobj__324; - PyObject *__pyx_codeobj__325; - PyObject *__pyx_codeobj__326; - PyObject *__pyx_codeobj__328; - PyObject *__pyx_codeobj__330; - PyObject *__pyx_codeobj__332; - PyObject *__pyx_codeobj__333; - PyObject *__pyx_codeobj__334; - PyObject *__pyx_codeobj__336; - PyObject *__pyx_codeobj__337; - PyObject *__pyx_codeobj__338; - PyObject *__pyx_codeobj__339; - PyObject *__pyx_codeobj__340; - PyObject *__pyx_codeobj__341; - PyObject *__pyx_codeobj__342; - PyObject *__pyx_codeobj__344; - PyObject *__pyx_codeobj__345; - PyObject *__pyx_codeobj__346; - PyObject *__pyx_codeobj__347; - PyObject *__pyx_codeobj__348; - PyObject *__pyx_codeobj__349; - PyObject *__pyx_codeobj__350; - PyObject *__pyx_codeobj__351; - PyObject *__pyx_codeobj__352; - PyObject *__pyx_codeobj__353; - PyObject *__pyx_codeobj__354; - PyObject *__pyx_codeobj__355; - PyObject *__pyx_codeobj__356; - PyObject *__pyx_codeobj__357; - PyObject *__pyx_codeobj__358; - PyObject *__pyx_codeobj__359; - PyObject *__pyx_codeobj__360; - PyObject *__pyx_codeobj__361; - PyObject *__pyx_codeobj__362; - PyObject *__pyx_codeobj__363; - PyObject *__pyx_codeobj__364; - PyObject *__pyx_codeobj__365; - PyObject *__pyx_codeobj__366; - PyObject *__pyx_codeobj__367; - PyObject *__pyx_codeobj__368; - PyObject *__pyx_codeobj__369; - PyObject *__pyx_codeobj__370; - PyObject *__pyx_codeobj__371; - PyObject *__pyx_codeobj__372; - PyObject *__pyx_codeobj__373; - PyObject *__pyx_codeobj__374; - PyObject *__pyx_codeobj__375; - PyObject *__pyx_codeobj__376; - PyObject *__pyx_codeobj__377; - PyObject *__pyx_codeobj__378; - PyObject *__pyx_codeobj__379; - PyObject *__pyx_codeobj__380; - PyObject *__pyx_codeobj__381; - PyObject *__pyx_codeobj__382; - PyObject *__pyx_codeobj__383; - PyObject *__pyx_codeobj__384; - PyObject *__pyx_codeobj__385; - PyObject *__pyx_codeobj__386; - PyObject *__pyx_codeobj__387; - PyObject *__pyx_codeobj__388; - PyObject *__pyx_codeobj__389; - PyObject *__pyx_codeobj__390; - PyObject *__pyx_codeobj__391; - PyObject *__pyx_codeobj__392; - PyObject *__pyx_codeobj__393; - PyObject *__pyx_codeobj__394; - PyObject *__pyx_codeobj__395; - PyObject *__pyx_codeobj__396; - PyObject *__pyx_codeobj__397; - PyObject *__pyx_codeobj__398; - PyObject *__pyx_codeobj__400; - PyObject *__pyx_codeobj__401; - PyObject *__pyx_codeobj__402; - PyObject *__pyx_codeobj__403; - PyObject *__pyx_codeobj__404; - PyObject *__pyx_codeobj__405; - PyObject *__pyx_codeobj__406; - PyObject *__pyx_codeobj__407; - PyObject *__pyx_codeobj__408; - PyObject *__pyx_codeobj__409; - PyObject *__pyx_codeobj__410; - PyObject *__pyx_codeobj__411; - PyObject *__pyx_codeobj__413; - PyObject *__pyx_codeobj__415; - PyObject *__pyx_codeobj__416; - PyObject *__pyx_codeobj__418; - PyObject *__pyx_codeobj__419; - PyObject *__pyx_codeobj__420; - PyObject *__pyx_codeobj__421; - PyObject *__pyx_codeobj__422; - PyObject *__pyx_codeobj__423; - PyObject *__pyx_codeobj__424; - PyObject *__pyx_codeobj__425; - PyObject *__pyx_codeobj__427; - PyObject *__pyx_codeobj__429; - PyObject *__pyx_codeobj__431; - PyObject *__pyx_codeobj__433; - PyObject *__pyx_codeobj__435; - PyObject *__pyx_codeobj__437; - PyObject *__pyx_codeobj__438; - PyObject *__pyx_codeobj__440; - PyObject *__pyx_codeobj__442; - PyObject *__pyx_codeobj__444; - PyObject *__pyx_codeobj__445; - PyObject *__pyx_codeobj__446; - PyObject *__pyx_codeobj__447; - PyObject *__pyx_codeobj__448; - PyObject *__pyx_codeobj__450; - PyObject *__pyx_codeobj__452; - PyObject *__pyx_codeobj__453; - PyObject *__pyx_codeobj__454; - PyObject *__pyx_codeobj__455; - PyObject *__pyx_codeobj__456; - PyObject *__pyx_codeobj__457; - PyObject *__pyx_codeobj__459; - PyObject *__pyx_codeobj__460; - PyObject *__pyx_codeobj__461; - PyObject *__pyx_codeobj__462; - PyObject *__pyx_codeobj__463; - PyObject *__pyx_codeobj__464; - PyObject *__pyx_codeobj__465; - PyObject *__pyx_codeobj__466; - PyObject *__pyx_codeobj__467; - PyObject *__pyx_codeobj__469; - PyObject *__pyx_codeobj__471; - PyObject *__pyx_codeobj__472; - PyObject *__pyx_codeobj__473; - PyObject *__pyx_codeobj__474; - PyObject *__pyx_codeobj__475; - PyObject *__pyx_codeobj__477; - PyObject *__pyx_codeobj__479; - PyObject *__pyx_codeobj__481; - PyObject *__pyx_codeobj__483; - PyObject *__pyx_codeobj__484; - PyObject *__pyx_codeobj__485; - PyObject *__pyx_codeobj__487; - PyObject *__pyx_codeobj__488; - PyObject *__pyx_codeobj__489; - PyObject *__pyx_codeobj__490; - PyObject *__pyx_codeobj__492; - PyObject *__pyx_codeobj__493; - PyObject *__pyx_codeobj__494; - PyObject *__pyx_codeobj__495; - PyObject *__pyx_codeobj__496; - PyObject *__pyx_codeobj__498; - PyObject *__pyx_codeobj__499; - PyObject *__pyx_codeobj__500; - PyObject *__pyx_codeobj__501; - PyObject *__pyx_codeobj__502; -} __pyx_mstate; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_keys; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values; + PyObject *__pyx_tuple[10]; + PyObject *__pyx_codeobj_tab[369]; + PyObject *__pyx_string_tab[1153]; + PyObject *__pyx_number_tab[22]; +/* #### Code section: module_state_contents ### */ +/* CommonTypesMetaclass.module_state_decls */ +PyTypeObject *__pyx_CommonTypesMetaclassType; + +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + +/* CythonFunctionShared.module_state_decls */ +PyTypeObject *__pyx_CyFunctionType; + +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; #if CYTHON_USE_MODULE_STATE #ifdef __cplusplus namespace { - extern struct PyModuleDef __pyx_moduledef; +extern struct PyModuleDef __pyx_moduledef; } /* anonymous namespace */ #else static struct PyModuleDef __pyx_moduledef; #endif -#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) +#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) -#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) - -#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) #else -static __pyx_mstate __pyx_mstate_global_static = +static __pyx_mstatetype __pyx_mstate_global_static = #ifdef __cplusplus {}; #else {0}; #endif -static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; -#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_kp_u_ __pyx_string_tab[0] +#define __pyx_kp_u_3 __pyx_string_tab[1] +#define __pyx_kp_u_Allocation_Error_TA_ALLOC_ERR __pyx_string_tab[2] +#define __pyx_kp_u_Bad_Object_TA_BAD_OBJECT __pyx_string_tab[3] +#define __pyx_kp_u_Bad_Parameter_TA_BAD_PARAM __pyx_string_tab[4] +#define __pyx_kp_u_Bull_Bear_Pattern_Bearish_0_Neut __pyx_string_tab[5] +#define __pyx_kp_u_Dashed_Line __pyx_string_tab[6] +#define __pyx_kp_u_Dotted_Line __pyx_string_tab[7] +#define __pyx_kp_u_Double_Exponential_Moving_Averag __pyx_string_tab[8] +#define __pyx_kp_u_Exponential_Moving_Average __pyx_string_tab[9] +#define __pyx_kp_u_Function_Not_Found_TA_FUNC_NOT_F __pyx_string_tab[10] +#define __pyx_kp_u_Function_has_an_unstable_period __pyx_string_tab[11] +#define __pyx_kp_u_Group_Not_Found_TA_GROUP_NOT_FOU __pyx_string_tab[12] +#define __pyx_kp_u_Input_Not_All_Initialized_TA_INP __pyx_string_tab[13] +#define __pyx_kp_u_Inputs __pyx_string_tab[14] +#define __pyx_kp_u_Internal_Error_TA_INTERNAL_ERROR __pyx_string_tab[15] +#define __pyx_kp_u_Invalid_Handle_TA_INVALID_HANDLE __pyx_string_tab[16] +#define __pyx_kp_u_Invalid_List_Type_TA_INVALID_LIS __pyx_string_tab[17] +#define __pyx_kp_u_Invalid_Parameter_Function_TA_IN __pyx_string_tab[18] +#define __pyx_kp_u_Invalid_Parameter_Holder_TA_INVA __pyx_string_tab[19] +#define __pyx_kp_u_Invalid_Parameter_Holder_Type_TA __pyx_string_tab[20] +#define __pyx_kp_u_Invalid_parameter_value_for __pyx_string_tab[21] +#define __pyx_kp_u_Kaufman_Adaptive_Moving_Average __pyx_string_tab[22] +#define __pyx_kp_u_Library_Not_Initialized_TA_LIB_N __pyx_string_tab[23] +#define __pyx_kp_u_MESA_Adaptive_Moving_Average __pyx_string_tab[24] +#define __pyx_kp_u_None __pyx_string_tab[25] +#define __pyx_kp_u_Not_Supported_TA_NOT_SUPPORTED __pyx_string_tab[26] +#define __pyx_kp_u_Not_enough_price_arguments_expec __pyx_string_tab[27] +#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[28] +#define __pyx_kp_u_Out_of_Range_End_Index_TA_OUT_OF __pyx_string_tab[29] +#define __pyx_kp_u_Out_of_Range_Start_Index_TA_OUT __pyx_string_tab[30] +#define __pyx_kp_u_Output_Not_All_Initialized_TA_OU __pyx_string_tab[31] +#define __pyx_kp_u_Output_can_be_negative __pyx_string_tab[32] +#define __pyx_kp_u_Output_can_be_positive __pyx_string_tab[33] +#define __pyx_kp_u_Output_can_be_zero __pyx_string_tab[34] +#define __pyx_kp_u_Output_is_a_candlestick __pyx_string_tab[35] +#define __pyx_kp_u_Output_is_over_volume __pyx_string_tab[36] +#define __pyx_kp_u_Output_scale_same_as_input __pyx_string_tab[37] +#define __pyx_kp_u_Outputs __pyx_string_tab[38] +#define __pyx_kp_u_Parameters __pyx_string_tab[39] +#define __pyx_kp_u_Pattern_Bool __pyx_string_tab[40] +#define __pyx_kp_u_Simple_Moving_Average __pyx_string_tab[41] +#define __pyx_kp_u_Strength_Pattern_200_100_Bearish __pyx_string_tab[42] +#define __pyx_kp_u_This_is_a_pythonic_wrapper_arou __pyx_string_tab[43] +#define __pyx_kp_u_Too_many_price_arguments_expecte __pyx_string_tab[44] +#define __pyx_kp_u_Triangular_Moving_Average __pyx_string_tab[45] +#define __pyx_kp_u_Triple_Exponential_Moving_Averag __pyx_string_tab[46] +#define __pyx_kp_u_Triple_Generalized_Double_Expone __pyx_string_tab[47] +#define __pyx_kp_u_Unknown_Error __pyx_string_tab[48] +#define __pyx_kp_u_Unknown_Error_TA_UNKNOWN_ERR __pyx_string_tab[49] +#define __pyx_kp_u_Values_represent_a_lower_limit __pyx_string_tab[50] +#define __pyx_kp_u_Values_represent_an_upper_limit __pyx_string_tab[51] +#define __pyx_kp_u_Weighted_Moving_Average __pyx_string_tab[52] +#define __pyx_kp_u__10 __pyx_string_tab[53] +#define __pyx_kp_u__11 __pyx_string_tab[54] +#define __pyx_kp_u__12 __pyx_string_tab[55] +#define __pyx_kp_u__13 __pyx_string_tab[56] +#define __pyx_kp_u__14 __pyx_string_tab[57] +#define __pyx_kp_u__15 __pyx_string_tab[58] +#define __pyx_kp_u__2 __pyx_string_tab[59] +#define __pyx_kp_u__3 __pyx_string_tab[60] +#define __pyx_kp_u__4 __pyx_string_tab[61] +#define __pyx_kp_u__5 __pyx_string_tab[62] +#define __pyx_kp_u__6 __pyx_string_tab[63] +#define __pyx_kp_u__7 __pyx_string_tab[64] +#define __pyx_kp_u__8 __pyx_string_tab[65] +#define __pyx_kp_u__9 __pyx_string_tab[66] +#define __pyx_kp_u_add_note __pyx_string_tab[67] +#define __pyx_kp_u_any_ndarray __pyx_string_tab[68] +#define __pyx_kp_u_display_name_s_group_s __pyx_string_tab[69] +#define __pyx_kp_u_expected __pyx_string_tab[70] +#define __pyx_kp_u_function_failed_with_error_code __pyx_string_tab[71] +#define __pyx_kp_u_got __pyx_string_tab[72] +#define __pyx_kp_u_input_array_has_wrong_dimensions __pyx_string_tab[73] +#define __pyx_kp_u_input_array_lengths_are_differen __pyx_string_tab[74] +#define __pyx_kp_u_input_array_type_is_not_double __pyx_string_tab[75] +#define __pyx_kp_u_input_arrays_2 __pyx_string_tab[76] +#define __pyx_kp_u_input_arrays_parameter_missing_r __pyx_string_tab[77] +#define __pyx_kp_u_integer_values_are_100_0_or_100 __pyx_string_tab[78] +#define __pyx_kp_u_numpy__core_multiarray_failed_to __pyx_string_tab[79] +#define __pyx_kp_u_numpy__core_umath_failed_to_impo __pyx_string_tab[80] +#define __pyx_kp_u_s_2 __pyx_string_tab[81] +#define __pyx_kp_u_s_3 __pyx_string_tab[82] +#define __pyx_kp_u_s_4 __pyx_string_tab[83] +#define __pyx_kp_u_stream__s __pyx_string_tab[84] +#define __pyx_kp_u_talib__abstract_pxi __pyx_string_tab[85] +#define __pyx_kp_u_talib__common_pxi __pyx_string_tab[86] +#define __pyx_kp_u_talib__func_pxi __pyx_string_tab[87] +#define __pyx_kp_u_talib__stream_pxi __pyx_string_tab[88] +#define __pyx_kp_u_talib_collections __pyx_string_tab[89] +#define __pyx_kp_u_talib_math __pyx_string_tab[90] +#define __pyx_kp_u_talib_numpy __pyx_string_tab[91] +#define __pyx_kp_u_talib_ordereddict __pyx_string_tab[92] +#define __pyx_kp_u_talib_pandas __pyx_string_tab[93] +#define __pyx_kp_u_talib_polars __pyx_string_tab[94] +#define __pyx_kp_u_talib_sys __pyx_string_tab[95] +#define __pyx_kp_u_talib_threading __pyx_string_tab[96] +#define __pyx_n_u_ACCBANDS __pyx_string_tab[97] +#define __pyx_n_u_ACOS __pyx_string_tab[98] +#define __pyx_n_u_AD __pyx_string_tab[99] +#define __pyx_n_u_ADD __pyx_string_tab[100] +#define __pyx_n_u_ADOSC __pyx_string_tab[101] +#define __pyx_n_u_ADX __pyx_string_tab[102] +#define __pyx_n_u_ADXR __pyx_string_tab[103] +#define __pyx_n_u_ALL __pyx_string_tab[104] +#define __pyx_n_u_APO __pyx_string_tab[105] +#define __pyx_n_u_AROON __pyx_string_tab[106] +#define __pyx_n_u_AROONOSC __pyx_string_tab[107] +#define __pyx_n_u_ARRAY_TYPES __pyx_string_tab[108] +#define __pyx_n_u_ASIN __pyx_string_tab[109] +#define __pyx_n_u_ATAN __pyx_string_tab[110] +#define __pyx_n_u_ATR __pyx_string_tab[111] +#define __pyx_n_u_AVGDEV __pyx_string_tab[112] +#define __pyx_n_u_AVGPRICE __pyx_string_tab[113] +#define __pyx_n_u_AllCandleSettings __pyx_string_tab[114] +#define __pyx_n_u_BBANDS __pyx_string_tab[115] +#define __pyx_n_u_BETA __pyx_string_tab[116] +#define __pyx_n_u_BOP __pyx_string_tab[117] +#define __pyx_n_u_BodyDoji __pyx_string_tab[118] +#define __pyx_n_u_BodyLong __pyx_string_tab[119] +#define __pyx_n_u_BodyShort __pyx_string_tab[120] +#define __pyx_n_u_BodyVeryLong __pyx_string_tab[121] +#define __pyx_n_u_CCI __pyx_string_tab[122] +#define __pyx_n_u_CDL2CROWS __pyx_string_tab[123] +#define __pyx_n_u_CDL3BLACKCROWS __pyx_string_tab[124] +#define __pyx_n_u_CDL3INSIDE __pyx_string_tab[125] +#define __pyx_n_u_CDL3LINESTRIKE __pyx_string_tab[126] +#define __pyx_n_u_CDL3OUTSIDE __pyx_string_tab[127] +#define __pyx_n_u_CDL3STARSINSOUTH __pyx_string_tab[128] +#define __pyx_n_u_CDL3WHITESOLDIERS __pyx_string_tab[129] +#define __pyx_n_u_CDLABANDONEDBABY __pyx_string_tab[130] +#define __pyx_n_u_CDLADVANCEBLOCK __pyx_string_tab[131] +#define __pyx_n_u_CDLBELTHOLD __pyx_string_tab[132] +#define __pyx_n_u_CDLBREAKAWAY __pyx_string_tab[133] +#define __pyx_n_u_CDLCLOSINGMARUBOZU __pyx_string_tab[134] +#define __pyx_n_u_CDLCONCEALBABYSWALL __pyx_string_tab[135] +#define __pyx_n_u_CDLCOUNTERATTACK __pyx_string_tab[136] +#define __pyx_n_u_CDLDARKCLOUDCOVER __pyx_string_tab[137] +#define __pyx_n_u_CDLDOJI __pyx_string_tab[138] +#define __pyx_n_u_CDLDOJISTAR __pyx_string_tab[139] +#define __pyx_n_u_CDLDRAGONFLYDOJI __pyx_string_tab[140] +#define __pyx_n_u_CDLENGULFING __pyx_string_tab[141] +#define __pyx_n_u_CDLEVENINGDOJISTAR __pyx_string_tab[142] +#define __pyx_n_u_CDLEVENINGSTAR __pyx_string_tab[143] +#define __pyx_n_u_CDLGAPSIDESIDEWHITE __pyx_string_tab[144] +#define __pyx_n_u_CDLGRAVESTONEDOJI __pyx_string_tab[145] +#define __pyx_n_u_CDLHAMMER __pyx_string_tab[146] +#define __pyx_n_u_CDLHANGINGMAN __pyx_string_tab[147] +#define __pyx_n_u_CDLHARAMI __pyx_string_tab[148] +#define __pyx_n_u_CDLHARAMICROSS __pyx_string_tab[149] +#define __pyx_n_u_CDLHIGHWAVE __pyx_string_tab[150] +#define __pyx_n_u_CDLHIKKAKE __pyx_string_tab[151] +#define __pyx_n_u_CDLHIKKAKEMOD __pyx_string_tab[152] +#define __pyx_n_u_CDLHOMINGPIGEON __pyx_string_tab[153] +#define __pyx_n_u_CDLIDENTICAL3CROWS __pyx_string_tab[154] +#define __pyx_n_u_CDLINNECK __pyx_string_tab[155] +#define __pyx_n_u_CDLINVERTEDHAMMER __pyx_string_tab[156] +#define __pyx_n_u_CDLKICKING __pyx_string_tab[157] +#define __pyx_n_u_CDLKICKINGBYLENGTH __pyx_string_tab[158] +#define __pyx_n_u_CDLLADDERBOTTOM __pyx_string_tab[159] +#define __pyx_n_u_CDLLONGLEGGEDDOJI __pyx_string_tab[160] +#define __pyx_n_u_CDLLONGLINE __pyx_string_tab[161] +#define __pyx_n_u_CDLMARUBOZU __pyx_string_tab[162] +#define __pyx_n_u_CDLMATCHINGLOW __pyx_string_tab[163] +#define __pyx_n_u_CDLMATHOLD __pyx_string_tab[164] +#define __pyx_n_u_CDLMORNINGDOJISTAR __pyx_string_tab[165] +#define __pyx_n_u_CDLMORNINGSTAR __pyx_string_tab[166] +#define __pyx_n_u_CDLONNECK __pyx_string_tab[167] +#define __pyx_n_u_CDLPIERCING __pyx_string_tab[168] +#define __pyx_n_u_CDLRICKSHAWMAN __pyx_string_tab[169] +#define __pyx_n_u_CDLRISEFALL3METHODS __pyx_string_tab[170] +#define __pyx_n_u_CDLSEPARATINGLINES __pyx_string_tab[171] +#define __pyx_n_u_CDLSHOOTINGSTAR __pyx_string_tab[172] +#define __pyx_n_u_CDLSHORTLINE __pyx_string_tab[173] +#define __pyx_n_u_CDLSPINNINGTOP __pyx_string_tab[174] +#define __pyx_n_u_CDLSTALLEDPATTERN __pyx_string_tab[175] +#define __pyx_n_u_CDLSTICKSANDWICH __pyx_string_tab[176] +#define __pyx_n_u_CDLTAKURI __pyx_string_tab[177] +#define __pyx_n_u_CDLTASUKIGAP __pyx_string_tab[178] +#define __pyx_n_u_CDLTHRUSTING __pyx_string_tab[179] +#define __pyx_n_u_CDLTRISTAR __pyx_string_tab[180] +#define __pyx_n_u_CDLUNIQUE3RIVER __pyx_string_tab[181] +#define __pyx_n_u_CDLUPSIDEGAP2CROWS __pyx_string_tab[182] +#define __pyx_n_u_CDLXSIDEGAP3METHODS __pyx_string_tab[183] +#define __pyx_n_u_CEIL __pyx_string_tab[184] +#define __pyx_n_u_CMO __pyx_string_tab[185] +#define __pyx_n_u_CORREL __pyx_string_tab[186] +#define __pyx_n_u_COS __pyx_string_tab[187] +#define __pyx_n_u_COSH __pyx_string_tab[188] +#define __pyx_n_u_CandleSettingType __pyx_string_tab[189] +#define __pyx_n_u_DEMA __pyx_string_tab[190] +#define __pyx_n_u_DIV __pyx_string_tab[191] +#define __pyx_n_u_DX __pyx_string_tab[192] +#define __pyx_n_u_DataFrame __pyx_string_tab[193] +#define __pyx_n_u_Dot __pyx_string_tab[194] +#define __pyx_n_u_EMA __pyx_string_tab[195] +#define __pyx_n_u_EXP __pyx_string_tab[196] +#define __pyx_n_u_Equal __pyx_string_tab[197] +#define __pyx_n_u_FLOOR __pyx_string_tab[198] +#define __pyx_n_u_Far __pyx_string_tab[199] +#define __pyx_n_u_Function __pyx_string_tab[200] +#define __pyx_n_u_Function___call __pyx_string_tab[201] +#define __pyx_n_u_Function___call_function __pyx_string_tab[202] +#define __pyx_n_u_Function___check_opt_input_value __pyx_string_tab[203] +#define __pyx_n_u_Function___get_opt_input_value __pyx_string_tab[204] +#define __pyx_n_u_Function___init __pyx_string_tab[205] +#define __pyx_n_u_Function___input_price_series_na __pyx_string_tab[206] +#define __pyx_n_u_Function___local __pyx_string_tab[207] +#define __pyx_n_u_Function___repr __pyx_string_tab[208] +#define __pyx_n_u_Function___str __pyx_string_tab[209] +#define __pyx_n_u_Function___unicode __pyx_string_tab[210] +#define __pyx_n_u_Function__call_function __pyx_string_tab[211] +#define __pyx_n_u_Function__check_opt_input_value __pyx_string_tab[212] +#define __pyx_n_u_Function__get_opt_input_value __pyx_string_tab[213] +#define __pyx_n_u_Function__input_price_series_na __pyx_string_tab[214] +#define __pyx_n_u_Function__local __pyx_string_tab[215] +#define __pyx_n_u_Function__localdata __pyx_string_tab[216] +#define __pyx_n_u_Function__name __pyx_string_tab[217] +#define __pyx_n_u_Function__namestr __pyx_string_tab[218] +#define __pyx_n_u_Function_function_flags __pyx_string_tab[219] +#define __pyx_n_u_Function_get_input_arrays __pyx_string_tab[220] +#define __pyx_n_u_Function_get_input_names __pyx_string_tab[221] +#define __pyx_n_u_Function_get_parameters __pyx_string_tab[222] +#define __pyx_n_u_Function_info __pyx_string_tab[223] +#define __pyx_n_u_Function_lookback __pyx_string_tab[224] +#define __pyx_n_u_Function_output_flags __pyx_string_tab[225] +#define __pyx_n_u_Function_output_names __pyx_string_tab[226] +#define __pyx_n_u_Function_outputs __pyx_string_tab[227] +#define __pyx_n_u_Function_run __pyx_string_tab[228] +#define __pyx_n_u_Function_set_function_args __pyx_string_tab[229] +#define __pyx_n_u_Function_set_input_arrays __pyx_string_tab[230] +#define __pyx_n_u_Function_set_input_names __pyx_string_tab[231] +#define __pyx_n_u_Function_set_parameters __pyx_string_tab[232] +#define __pyx_n_u_HT_DCPERIOD __pyx_string_tab[233] +#define __pyx_n_u_HT_DCPHASE __pyx_string_tab[234] +#define __pyx_n_u_HT_PHASOR __pyx_string_tab[235] +#define __pyx_n_u_HT_SINE __pyx_string_tab[236] +#define __pyx_n_u_HT_TRENDLINE __pyx_string_tab[237] +#define __pyx_n_u_HT_TRENDMODE __pyx_string_tab[238] +#define __pyx_n_u_HighLow __pyx_string_tab[239] +#define __pyx_n_u_Histogram __pyx_string_tab[240] +#define __pyx_n_u_IMI __pyx_string_tab[241] +#define __pyx_n_u_INPUT_ARRAYS_TYPES __pyx_string_tab[242] +#define __pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS __pyx_string_tab[243] +#define __pyx_n_u_KAMA __pyx_string_tab[244] +#define __pyx_n_u_LINEARREG __pyx_string_tab[245] +#define __pyx_n_u_LINEARREG_ANGLE __pyx_string_tab[246] +#define __pyx_n_u_LINEARREG_INTERCEPT __pyx_string_tab[247] +#define __pyx_n_u_LINEARREG_SLOPE __pyx_string_tab[248] +#define __pyx_n_u_LN __pyx_string_tab[249] +#define __pyx_n_u_LOG10 __pyx_string_tab[250] +#define __pyx_n_u_Line __pyx_string_tab[251] +#define __pyx_n_u_MA __pyx_string_tab[252] +#define __pyx_n_u_MACD __pyx_string_tab[253] +#define __pyx_n_u_MACDEXT __pyx_string_tab[254] +#define __pyx_n_u_MACDFIX __pyx_string_tab[255] +#define __pyx_n_u_MAMA __pyx_string_tab[256] +#define __pyx_n_u_MAVP __pyx_string_tab[257] +#define __pyx_n_u_MAX __pyx_string_tab[258] +#define __pyx_n_u_MAXINDEX __pyx_string_tab[259] +#define __pyx_n_u_MA_Type __pyx_string_tab[260] +#define __pyx_n_u_MA_Type___getitem __pyx_string_tab[261] +#define __pyx_n_u_MA_Type___init __pyx_string_tab[262] +#define __pyx_n_u_MEDPRICE __pyx_string_tab[263] +#define __pyx_n_u_MFI __pyx_string_tab[264] +#define __pyx_n_u_MIDPOINT __pyx_string_tab[265] +#define __pyx_n_u_MIDPRICE __pyx_string_tab[266] +#define __pyx_n_u_MIN __pyx_string_tab[267] +#define __pyx_n_u_MININDEX __pyx_string_tab[268] +#define __pyx_n_u_MINMAX __pyx_string_tab[269] +#define __pyx_n_u_MINMAXINDEX __pyx_string_tab[270] +#define __pyx_n_u_MINUS_DI __pyx_string_tab[271] +#define __pyx_n_u_MINUS_DM __pyx_string_tab[272] +#define __pyx_n_u_MOM __pyx_string_tab[273] +#define __pyx_n_u_MULT __pyx_string_tab[274] +#define __pyx_n_u_NATR __pyx_string_tab[275] +#define __pyx_n_u_NONE __pyx_string_tab[276] +#define __pyx_n_u_Near __pyx_string_tab[277] +#define __pyx_n_u_OBV __pyx_string_tab[278] +#define __pyx_n_u_OrderedDict __pyx_string_tab[279] +#define __pyx_n_u_PANDAS_DATAFRAME __pyx_string_tab[280] +#define __pyx_n_u_PANDAS_SERIES __pyx_string_tab[281] +#define __pyx_n_u_PLUS_DI __pyx_string_tab[282] +#define __pyx_n_u_PLUS_DM __pyx_string_tab[283] +#define __pyx_n_u_POLARS_DATAFRAME __pyx_string_tab[284] +#define __pyx_n_u_POLARS_SERIES __pyx_string_tab[285] +#define __pyx_n_u_PPO __pyx_string_tab[286] +#define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[287] +#define __pyx_n_u_ROC __pyx_string_tab[288] +#define __pyx_n_u_ROCP __pyx_string_tab[289] +#define __pyx_n_u_ROCR __pyx_string_tab[290] +#define __pyx_n_u_ROCR100 __pyx_string_tab[291] +#define __pyx_n_u_RSI __pyx_string_tab[292] +#define __pyx_n_u_RangeType __pyx_string_tab[293] +#define __pyx_n_u_RealBody __pyx_string_tab[294] +#define __pyx_n_u_SAR __pyx_string_tab[295] +#define __pyx_n_u_SAREXT __pyx_string_tab[296] +#define __pyx_n_u_SIN __pyx_string_tab[297] +#define __pyx_n_u_SINH __pyx_string_tab[298] +#define __pyx_n_u_SMA __pyx_string_tab[299] +#define __pyx_n_u_SQRT __pyx_string_tab[300] +#define __pyx_n_u_STDDEV __pyx_string_tab[301] +#define __pyx_n_u_STOCH __pyx_string_tab[302] +#define __pyx_n_u_STOCHF __pyx_string_tab[303] +#define __pyx_n_u_STOCHRSI __pyx_string_tab[304] +#define __pyx_n_u_SUB __pyx_string_tab[305] +#define __pyx_n_u_SUM __pyx_string_tab[306] +#define __pyx_n_u_Series __pyx_string_tab[307] +#define __pyx_n_u_ShadowLong __pyx_string_tab[308] +#define __pyx_n_u_ShadowShort __pyx_string_tab[309] +#define __pyx_n_u_ShadowVeryLong __pyx_string_tab[310] +#define __pyx_n_u_ShadowVeryShort __pyx_string_tab[311] +#define __pyx_n_u_Shadows __pyx_string_tab[312] +#define __pyx_n_u_T3 __pyx_string_tab[313] +#define __pyx_n_u_TAN __pyx_string_tab[314] +#define __pyx_n_u_TANH __pyx_string_tab[315] +#define __pyx_n_u_TA_ACCBANDS __pyx_string_tab[316] +#define __pyx_n_u_TA_ACOS __pyx_string_tab[317] +#define __pyx_n_u_TA_AD __pyx_string_tab[318] +#define __pyx_n_u_TA_ADD __pyx_string_tab[319] +#define __pyx_n_u_TA_ADOSC __pyx_string_tab[320] +#define __pyx_n_u_TA_ADX __pyx_string_tab[321] +#define __pyx_n_u_TA_ADXR __pyx_string_tab[322] +#define __pyx_n_u_TA_APO __pyx_string_tab[323] +#define __pyx_n_u_TA_AROON __pyx_string_tab[324] +#define __pyx_n_u_TA_AROONOSC __pyx_string_tab[325] +#define __pyx_n_u_TA_ASIN __pyx_string_tab[326] +#define __pyx_n_u_TA_ATAN __pyx_string_tab[327] +#define __pyx_n_u_TA_ATR __pyx_string_tab[328] +#define __pyx_n_u_TA_AVGDEV __pyx_string_tab[329] +#define __pyx_n_u_TA_AVGPRICE __pyx_string_tab[330] +#define __pyx_n_u_TA_BBANDS __pyx_string_tab[331] +#define __pyx_n_u_TA_BETA __pyx_string_tab[332] +#define __pyx_n_u_TA_BOP __pyx_string_tab[333] +#define __pyx_n_u_TA_CCI __pyx_string_tab[334] +#define __pyx_n_u_TA_CDL2CROWS __pyx_string_tab[335] +#define __pyx_n_u_TA_CDL3BLACKCROWS __pyx_string_tab[336] +#define __pyx_n_u_TA_CDL3INSIDE __pyx_string_tab[337] +#define __pyx_n_u_TA_CDL3LINESTRIKE __pyx_string_tab[338] +#define __pyx_n_u_TA_CDL3OUTSIDE __pyx_string_tab[339] +#define __pyx_n_u_TA_CDL3STARSINSOUTH __pyx_string_tab[340] +#define __pyx_n_u_TA_CDL3WHITESOLDIERS __pyx_string_tab[341] +#define __pyx_n_u_TA_CDLABANDONEDBABY __pyx_string_tab[342] +#define __pyx_n_u_TA_CDLADVANCEBLOCK __pyx_string_tab[343] +#define __pyx_n_u_TA_CDLBELTHOLD __pyx_string_tab[344] +#define __pyx_n_u_TA_CDLBREAKAWAY __pyx_string_tab[345] +#define __pyx_n_u_TA_CDLCLOSINGMARUBOZU __pyx_string_tab[346] +#define __pyx_n_u_TA_CDLCONCEALBABYSWALL __pyx_string_tab[347] +#define __pyx_n_u_TA_CDLCOUNTERATTACK __pyx_string_tab[348] +#define __pyx_n_u_TA_CDLDARKCLOUDCOVER __pyx_string_tab[349] +#define __pyx_n_u_TA_CDLDOJI __pyx_string_tab[350] +#define __pyx_n_u_TA_CDLDOJISTAR __pyx_string_tab[351] +#define __pyx_n_u_TA_CDLDRAGONFLYDOJI __pyx_string_tab[352] +#define __pyx_n_u_TA_CDLENGULFING __pyx_string_tab[353] +#define __pyx_n_u_TA_CDLEVENINGDOJISTAR __pyx_string_tab[354] +#define __pyx_n_u_TA_CDLEVENINGSTAR __pyx_string_tab[355] +#define __pyx_n_u_TA_CDLGAPSIDESIDEWHITE __pyx_string_tab[356] +#define __pyx_n_u_TA_CDLGRAVESTONEDOJI __pyx_string_tab[357] +#define __pyx_n_u_TA_CDLHAMMER __pyx_string_tab[358] +#define __pyx_n_u_TA_CDLHANGINGMAN __pyx_string_tab[359] +#define __pyx_n_u_TA_CDLHARAMI __pyx_string_tab[360] +#define __pyx_n_u_TA_CDLHARAMICROSS __pyx_string_tab[361] +#define __pyx_n_u_TA_CDLHIGHWAVE __pyx_string_tab[362] +#define __pyx_n_u_TA_CDLHIKKAKE __pyx_string_tab[363] +#define __pyx_n_u_TA_CDLHIKKAKEMOD __pyx_string_tab[364] +#define __pyx_n_u_TA_CDLHOMINGPIGEON __pyx_string_tab[365] +#define __pyx_n_u_TA_CDLIDENTICAL3CROWS __pyx_string_tab[366] +#define __pyx_n_u_TA_CDLINNECK __pyx_string_tab[367] +#define __pyx_n_u_TA_CDLINVERTEDHAMMER __pyx_string_tab[368] +#define __pyx_n_u_TA_CDLKICKING __pyx_string_tab[369] +#define __pyx_n_u_TA_CDLKICKINGBYLENGTH __pyx_string_tab[370] +#define __pyx_n_u_TA_CDLLADDERBOTTOM __pyx_string_tab[371] +#define __pyx_n_u_TA_CDLLONGLEGGEDDOJI __pyx_string_tab[372] +#define __pyx_n_u_TA_CDLLONGLINE __pyx_string_tab[373] +#define __pyx_n_u_TA_CDLMARUBOZU __pyx_string_tab[374] +#define __pyx_n_u_TA_CDLMATCHINGLOW __pyx_string_tab[375] +#define __pyx_n_u_TA_CDLMATHOLD __pyx_string_tab[376] +#define __pyx_n_u_TA_CDLMORNINGDOJISTAR __pyx_string_tab[377] +#define __pyx_n_u_TA_CDLMORNINGSTAR __pyx_string_tab[378] +#define __pyx_n_u_TA_CDLONNECK __pyx_string_tab[379] +#define __pyx_n_u_TA_CDLPIERCING __pyx_string_tab[380] +#define __pyx_n_u_TA_CDLRICKSHAWMAN __pyx_string_tab[381] +#define __pyx_n_u_TA_CDLRISEFALL3METHODS __pyx_string_tab[382] +#define __pyx_n_u_TA_CDLSEPARATINGLINES __pyx_string_tab[383] +#define __pyx_n_u_TA_CDLSHOOTINGSTAR __pyx_string_tab[384] +#define __pyx_n_u_TA_CDLSHORTLINE __pyx_string_tab[385] +#define __pyx_n_u_TA_CDLSPINNINGTOP __pyx_string_tab[386] +#define __pyx_n_u_TA_CDLSTALLEDPATTERN __pyx_string_tab[387] +#define __pyx_n_u_TA_CDLSTICKSANDWICH __pyx_string_tab[388] +#define __pyx_n_u_TA_CDLTAKURI __pyx_string_tab[389] +#define __pyx_n_u_TA_CDLTASUKIGAP __pyx_string_tab[390] +#define __pyx_n_u_TA_CDLTHRUSTING __pyx_string_tab[391] +#define __pyx_n_u_TA_CDLTRISTAR __pyx_string_tab[392] +#define __pyx_n_u_TA_CDLUNIQUE3RIVER __pyx_string_tab[393] +#define __pyx_n_u_TA_CDLUPSIDEGAP2CROWS __pyx_string_tab[394] +#define __pyx_n_u_TA_CDLXSIDEGAP3METHODS __pyx_string_tab[395] +#define __pyx_n_u_TA_CEIL __pyx_string_tab[396] +#define __pyx_n_u_TA_CMO __pyx_string_tab[397] +#define __pyx_n_u_TA_CORREL __pyx_string_tab[398] +#define __pyx_n_u_TA_COS __pyx_string_tab[399] +#define __pyx_n_u_TA_COSH __pyx_string_tab[400] +#define __pyx_n_u_TA_DEMA __pyx_string_tab[401] +#define __pyx_n_u_TA_DIV __pyx_string_tab[402] +#define __pyx_n_u_TA_DX __pyx_string_tab[403] +#define __pyx_n_u_TA_EMA __pyx_string_tab[404] +#define __pyx_n_u_TA_EXP __pyx_string_tab[405] +#define __pyx_n_u_TA_FLOOR __pyx_string_tab[406] +#define __pyx_n_u_TA_FUNCTION_NAMES __pyx_string_tab[407] +#define __pyx_n_u_TA_FUNC_FLAGS __pyx_string_tab[408] +#define __pyx_n_u_TA_FuncTableAlloc __pyx_string_tab[409] +#define __pyx_n_u_TA_FuncTableFree __pyx_string_tab[410] +#define __pyx_n_u_TA_GetFuncHandle __pyx_string_tab[411] +#define __pyx_n_u_TA_GetFuncInfo __pyx_string_tab[412] +#define __pyx_n_u_TA_GetInputParameterInfo __pyx_string_tab[413] +#define __pyx_n_u_TA_GetLookback __pyx_string_tab[414] +#define __pyx_n_u_TA_GetOptInputParameterInfo __pyx_string_tab[415] +#define __pyx_n_u_TA_GetOutputParameterInfo __pyx_string_tab[416] +#define __pyx_n_u_TA_GroupTableAlloc __pyx_string_tab[417] +#define __pyx_n_u_TA_GroupTableFree __pyx_string_tab[418] +#define __pyx_n_u_TA_HT_DCPERIOD __pyx_string_tab[419] +#define __pyx_n_u_TA_HT_DCPHASE __pyx_string_tab[420] +#define __pyx_n_u_TA_HT_PHASOR __pyx_string_tab[421] +#define __pyx_n_u_TA_HT_SINE __pyx_string_tab[422] +#define __pyx_n_u_TA_HT_TRENDLINE __pyx_string_tab[423] +#define __pyx_n_u_TA_HT_TRENDMODE __pyx_string_tab[424] +#define __pyx_n_u_TA_IMI __pyx_string_tab[425] +#define __pyx_n_u_TA_INPUT_FLAGS __pyx_string_tab[426] +#define __pyx_n_u_TA_Initialize __pyx_string_tab[427] +#define __pyx_n_u_TA_KAMA __pyx_string_tab[428] +#define __pyx_n_u_TA_LINEARREG __pyx_string_tab[429] +#define __pyx_n_u_TA_LINEARREG_ANGLE __pyx_string_tab[430] +#define __pyx_n_u_TA_LINEARREG_INTERCEPT __pyx_string_tab[431] +#define __pyx_n_u_TA_LINEARREG_SLOPE __pyx_string_tab[432] +#define __pyx_n_u_TA_LN __pyx_string_tab[433] +#define __pyx_n_u_TA_LOG10 __pyx_string_tab[434] +#define __pyx_n_u_TA_MA __pyx_string_tab[435] +#define __pyx_n_u_TA_MACD __pyx_string_tab[436] +#define __pyx_n_u_TA_MACDEXT __pyx_string_tab[437] +#define __pyx_n_u_TA_MACDFIX __pyx_string_tab[438] +#define __pyx_n_u_TA_MAMA __pyx_string_tab[439] +#define __pyx_n_u_TA_MAVP __pyx_string_tab[440] +#define __pyx_n_u_TA_MAX __pyx_string_tab[441] +#define __pyx_n_u_TA_MAXINDEX __pyx_string_tab[442] +#define __pyx_n_u_TA_MEDPRICE __pyx_string_tab[443] +#define __pyx_n_u_TA_MFI __pyx_string_tab[444] +#define __pyx_n_u_TA_MIDPOINT __pyx_string_tab[445] +#define __pyx_n_u_TA_MIDPRICE __pyx_string_tab[446] +#define __pyx_n_u_TA_MIN __pyx_string_tab[447] +#define __pyx_n_u_TA_MININDEX __pyx_string_tab[448] +#define __pyx_n_u_TA_MINMAX __pyx_string_tab[449] +#define __pyx_n_u_TA_MINMAXINDEX __pyx_string_tab[450] +#define __pyx_n_u_TA_MINUS_DI __pyx_string_tab[451] +#define __pyx_n_u_TA_MINUS_DM __pyx_string_tab[452] +#define __pyx_n_u_TA_MOM __pyx_string_tab[453] +#define __pyx_n_u_TA_MULT __pyx_string_tab[454] +#define __pyx_n_u_TA_NATR __pyx_string_tab[455] +#define __pyx_n_u_TA_OBV __pyx_string_tab[456] +#define __pyx_n_u_TA_OUTPUT_FLAGS __pyx_string_tab[457] +#define __pyx_n_u_TA_PLUS_DI __pyx_string_tab[458] +#define __pyx_n_u_TA_PLUS_DM __pyx_string_tab[459] +#define __pyx_n_u_TA_PPO __pyx_string_tab[460] +#define __pyx_n_u_TA_ParamHolderAlloc __pyx_string_tab[461] +#define __pyx_n_u_TA_ParamHolderFree __pyx_string_tab[462] +#define __pyx_n_u_TA_ROC __pyx_string_tab[463] +#define __pyx_n_u_TA_ROCP __pyx_string_tab[464] +#define __pyx_n_u_TA_ROCR __pyx_string_tab[465] +#define __pyx_n_u_TA_ROCR100 __pyx_string_tab[466] +#define __pyx_n_u_TA_RSI __pyx_string_tab[467] +#define __pyx_n_u_TA_RestoreCandleDefaultSettings __pyx_string_tab[468] +#define __pyx_n_u_TA_SAR __pyx_string_tab[469] +#define __pyx_n_u_TA_SAREXT __pyx_string_tab[470] +#define __pyx_n_u_TA_SIN __pyx_string_tab[471] +#define __pyx_n_u_TA_SINH __pyx_string_tab[472] +#define __pyx_n_u_TA_SMA __pyx_string_tab[473] +#define __pyx_n_u_TA_SQRT __pyx_string_tab[474] +#define __pyx_n_u_TA_STDDEV __pyx_string_tab[475] +#define __pyx_n_u_TA_STOCH __pyx_string_tab[476] +#define __pyx_n_u_TA_STOCHF __pyx_string_tab[477] +#define __pyx_n_u_TA_STOCHRSI __pyx_string_tab[478] +#define __pyx_n_u_TA_SUB __pyx_string_tab[479] +#define __pyx_n_u_TA_SUM __pyx_string_tab[480] +#define __pyx_n_u_TA_SetCandleSettings __pyx_string_tab[481] +#define __pyx_n_u_TA_SetCompatibility __pyx_string_tab[482] +#define __pyx_n_u_TA_SetOptInputParamInteger __pyx_string_tab[483] +#define __pyx_n_u_TA_SetOptInputParamReal __pyx_string_tab[484] +#define __pyx_n_u_TA_SetUnstablePeriod __pyx_string_tab[485] +#define __pyx_n_u_TA_Shutdown __pyx_string_tab[486] +#define __pyx_n_u_TA_T3 __pyx_string_tab[487] +#define __pyx_n_u_TA_TAN __pyx_string_tab[488] +#define __pyx_n_u_TA_TANH __pyx_string_tab[489] +#define __pyx_n_u_TA_TEMA __pyx_string_tab[490] +#define __pyx_n_u_TA_TRANGE __pyx_string_tab[491] +#define __pyx_n_u_TA_TRIMA __pyx_string_tab[492] +#define __pyx_n_u_TA_TRIX __pyx_string_tab[493] +#define __pyx_n_u_TA_TSF __pyx_string_tab[494] +#define __pyx_n_u_TA_TYPPRICE __pyx_string_tab[495] +#define __pyx_n_u_TA_ULTOSC __pyx_string_tab[496] +#define __pyx_n_u_TA_VAR __pyx_string_tab[497] +#define __pyx_n_u_TA_WCLPRICE __pyx_string_tab[498] +#define __pyx_n_u_TA_WILLR __pyx_string_tab[499] +#define __pyx_n_u_TA_WMA __pyx_string_tab[500] +#define __pyx_n_u_TEMA __pyx_string_tab[501] +#define __pyx_n_u_TRANGE __pyx_string_tab[502] +#define __pyx_n_u_TRIMA __pyx_string_tab[503] +#define __pyx_n_u_TRIX __pyx_string_tab[504] +#define __pyx_n_u_TSF __pyx_string_tab[505] +#define __pyx_n_u_TYPPRICE __pyx_string_tab[506] +#define __pyx_n_u_ULTOSC __pyx_string_tab[507] +#define __pyx_n_u_VAR __pyx_string_tab[508] +#define __pyx_n_u_WCLPRICE __pyx_string_tab[509] +#define __pyx_n_u_WILLR __pyx_string_tab[510] +#define __pyx_n_u_WMA __pyx_string_tab[511] +#define __pyx_n_u_acceleration __pyx_string_tab[512] +#define __pyx_n_u_accelerationinitlong __pyx_string_tab[513] +#define __pyx_n_u_accelerationinitshort __pyx_string_tab[514] +#define __pyx_n_u_accelerationlong __pyx_string_tab[515] +#define __pyx_n_u_accelerationmaxlong __pyx_string_tab[516] +#define __pyx_n_u_accelerationmaxshort __pyx_string_tab[517] +#define __pyx_n_u_accelerationshort __pyx_string_tab[518] +#define __pyx_n_u_all __pyx_string_tab[519] +#define __pyx_n_u_append __pyx_string_tab[520] +#define __pyx_n_u_arg __pyx_string_tab[521] +#define __pyx_n_u_args __pyx_string_tab[522] +#define __pyx_n_u_ascii __pyx_string_tab[523] +#define __pyx_n_u_astype __pyx_string_tab[524] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[525] +#define __pyx_n_u_avgperiod __pyx_string_tab[526] +#define __pyx_n_u_b __pyx_string_tab[527] +#define __pyx_n_u_begidx __pyx_string_tab[528] +#define __pyx_n_u_bytes2str __pyx_string_tab[529] +#define __pyx_n_u_call __pyx_string_tab[530] +#define __pyx_n_u_call_function __pyx_string_tab[531] +#define __pyx_n_u_check_opt_input_value __pyx_string_tab[532] +#define __pyx_n_u_class_getitem __pyx_string_tab[533] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[534] +#define __pyx_n_u_clone __pyx_string_tab[535] +#define __pyx_n_u_close __pyx_string_tab[536] +#define __pyx_n_u_close_data __pyx_string_tab[537] +#define __pyx_n_u_collections __pyx_string_tab[538] +#define __pyx_n_u_column_stack __pyx_string_tab[539] +#define __pyx_n_u_columns __pyx_string_tab[540] +#define __pyx_n_u_copy __pyx_string_tab[541] +#define __pyx_n_u_d __pyx_string_tab[542] +#define __pyx_n_u_decode __pyx_string_tab[543] +#define __pyx_n_u_default_value __pyx_string_tab[544] +#define __pyx_n_u_defaults __pyx_string_tab[545] +#define __pyx_n_u_display_name __pyx_string_tab[546] +#define __pyx_n_u_doc __pyx_string_tab[547] +#define __pyx_n_u_docs __pyx_string_tab[548] +#define __pyx_n_u_documentation __pyx_string_tab[549] +#define __pyx_n_u_empty __pyx_string_tab[550] +#define __pyx_n_u_endidx __pyx_string_tab[551] +#define __pyx_n_u_enumerate __pyx_string_tab[552] +#define __pyx_n_u_factor __pyx_string_tab[553] +#define __pyx_n_u_fastd_matype __pyx_string_tab[554] +#define __pyx_n_u_fastd_period __pyx_string_tab[555] +#define __pyx_n_u_fastk_period __pyx_string_tab[556] +#define __pyx_n_u_fastlimit __pyx_string_tab[557] +#define __pyx_n_u_fastmatype __pyx_string_tab[558] +#define __pyx_n_u_fastperiod __pyx_string_tab[559] +#define __pyx_n_u_flag __pyx_string_tab[560] +#define __pyx_n_u_flags __pyx_string_tab[561] +#define __pyx_n_u_flags_lookup_dict __pyx_string_tab[562] +#define __pyx_n_u_func __pyx_string_tab[563] +#define __pyx_n_u_func_args __pyx_string_tab[564] +#define __pyx_n_u_func_info __pyx_string_tab[565] +#define __pyx_n_u_func_line __pyx_string_tab[566] +#define __pyx_n_u_func_object __pyx_string_tab[567] +#define __pyx_n_u_function_flags __pyx_string_tab[568] +#define __pyx_n_u_function_name __pyx_string_tab[569] +#define __pyx_n_u_functions __pyx_string_tab[570] +#define __pyx_n_u_get_defaults_and_docs __pyx_string_tab[571] +#define __pyx_n_u_get_flags __pyx_string_tab[572] +#define __pyx_n_u_get_input_arrays __pyx_string_tab[573] +#define __pyx_n_u_get_input_names __pyx_string_tab[574] +#define __pyx_n_u_get_opt_input_value __pyx_string_tab[575] +#define __pyx_n_u_get_parameters __pyx_string_tab[576] +#define __pyx_n_u_getitem __pyx_string_tab[577] +#define __pyx_n_u_group __pyx_string_tab[578] +#define __pyx_n_u_groups __pyx_string_tab[579] +#define __pyx_n_u_help __pyx_string_tab[580] +#define __pyx_n_u_high __pyx_string_tab[581] +#define __pyx_n_u_high_data __pyx_string_tab[582] +#define __pyx_n_u_holder __pyx_string_tab[583] +#define __pyx_n_u_i __pyx_string_tab[584] +#define __pyx_n_u_id __pyx_string_tab[585] +#define __pyx_n_u_idx __pyx_string_tab[586] +#define __pyx_n_u_import_error __pyx_string_tab[587] +#define __pyx_n_u_in __pyx_string_tab[588] +#define __pyx_n_u_index __pyx_string_tab[589] +#define __pyx_n_u_info __pyx_string_tab[590] +#define __pyx_n_u_init __pyx_string_tab[591] +#define __pyx_n_u_input_arrays __pyx_string_tab[592] +#define __pyx_n_u_input_name __pyx_string_tab[593] +#define __pyx_n_u_input_names __pyx_string_tab[594] +#define __pyx_n_u_input_price_series_names __pyx_string_tab[595] +#define __pyx_n_u_input_price_series_names_2 __pyx_string_tab[596] +#define __pyx_n_u_integer __pyx_string_tab[597] +#define __pyx_n_u_is_coroutine __pyx_string_tab[598] +#define __pyx_n_u_is_empty __pyx_string_tab[599] +#define __pyx_n_u_items __pyx_string_tab[600] +#define __pyx_n_u_key __pyx_string_tab[601] +#define __pyx_n_u_keys __pyx_string_tab[602] +#define __pyx_n_u_kwargs __pyx_string_tab[603] +#define __pyx_n_u_length __pyx_string_tab[604] +#define __pyx_n_u_local __pyx_string_tab[605] +#define __pyx_n_u_local_2 __pyx_string_tab[606] +#define __pyx_n_u_log __pyx_string_tab[607] +#define __pyx_n_u_lookback __pyx_string_tab[608] +#define __pyx_n_u_lookup __pyx_string_tab[609] +#define __pyx_n_u_low __pyx_string_tab[610] +#define __pyx_n_u_low_data __pyx_string_tab[611] +#define __pyx_n_u_lower __pyx_string_tab[612] +#define __pyx_n_u_main __pyx_string_tab[613] +#define __pyx_n_u_math __pyx_string_tab[614] +#define __pyx_n_u_matype __pyx_string_tab[615] +#define __pyx_n_u_max __pyx_string_tab[616] +#define __pyx_n_u_max_int __pyx_string_tab[617] +#define __pyx_n_u_maximum __pyx_string_tab[618] +#define __pyx_n_u_maxperiod __pyx_string_tab[619] +#define __pyx_n_u_metaclass __pyx_string_tab[620] +#define __pyx_n_u_min __pyx_string_tab[621] +#define __pyx_n_u_min_int __pyx_string_tab[622] +#define __pyx_n_u_minperiod __pyx_string_tab[623] +#define __pyx_n_u_missing __pyx_string_tab[624] +#define __pyx_n_u_missing_keys __pyx_string_tab[625] +#define __pyx_n_u_module __pyx_string_tab[626] +#define __pyx_n_u_mro_entries __pyx_string_tab[627] +#define __pyx_n_u_msg __pyx_string_tab[628] +#define __pyx_n_u_n __pyx_string_tab[629] +#define __pyx_n_u_name __pyx_string_tab[630] +#define __pyx_n_u_name_2 __pyx_string_tab[631] +#define __pyx_n_u_nan __pyx_string_tab[632] +#define __pyx_n_u_nbdev __pyx_string_tab[633] +#define __pyx_n_u_nbdevdn __pyx_string_tab[634] +#define __pyx_n_u_nbdevup __pyx_string_tab[635] +#define __pyx_n_u_no_existing_input_arrays __pyx_string_tab[636] +#define __pyx_n_u_num_inputs __pyx_string_tab[637] +#define __pyx_n_u_num_opt_inputs __pyx_string_tab[638] +#define __pyx_n_u_num_outputs __pyx_string_tab[639] +#define __pyx_n_u_numpy __pyx_string_tab[640] +#define __pyx_n_u_object __pyx_string_tab[641] +#define __pyx_n_u_offsetonreverse __pyx_string_tab[642] +#define __pyx_n_u_open __pyx_string_tab[643] +#define __pyx_n_u_openInterest __pyx_string_tab[644] +#define __pyx_n_u_open_data __pyx_string_tab[645] +#define __pyx_n_u_optIn __pyx_string_tab[646] +#define __pyx_n_u_opt_input __pyx_string_tab[647] +#define __pyx_n_u_opt_input_values __pyx_string_tab[648] +#define __pyx_n_u_opt_inputs __pyx_string_tab[649] +#define __pyx_n_u_ordereddict __pyx_string_tab[650] +#define __pyx_n_u_out __pyx_string_tab[651] +#define __pyx_n_u_outaroondown __pyx_string_tab[652] +#define __pyx_n_u_outaroonup __pyx_string_tab[653] +#define __pyx_n_u_outbegidx __pyx_string_tab[654] +#define __pyx_n_u_outfama __pyx_string_tab[655] +#define __pyx_n_u_outfastd __pyx_string_tab[656] +#define __pyx_n_u_outfastk __pyx_string_tab[657] +#define __pyx_n_u_outinphase __pyx_string_tab[658] +#define __pyx_n_u_outinteger __pyx_string_tab[659] +#define __pyx_n_u_outinteger_data __pyx_string_tab[660] +#define __pyx_n_u_outleadsine __pyx_string_tab[661] +#define __pyx_n_u_outmacd __pyx_string_tab[662] +#define __pyx_n_u_outmacdhist __pyx_string_tab[663] +#define __pyx_n_u_outmacdsignal __pyx_string_tab[664] +#define __pyx_n_u_outmama __pyx_string_tab[665] +#define __pyx_n_u_outmax __pyx_string_tab[666] +#define __pyx_n_u_outmaxidx __pyx_string_tab[667] +#define __pyx_n_u_outmaxidx_data __pyx_string_tab[668] +#define __pyx_n_u_outmin __pyx_string_tab[669] +#define __pyx_n_u_outminidx __pyx_string_tab[670] +#define __pyx_n_u_outminidx_data __pyx_string_tab[671] +#define __pyx_n_u_outnbelement __pyx_string_tab[672] +#define __pyx_n_u_output __pyx_string_tab[673] +#define __pyx_n_u_output_flags __pyx_string_tab[674] +#define __pyx_n_u_output_name __pyx_string_tab[675] +#define __pyx_n_u_output_names __pyx_string_tab[676] +#define __pyx_n_u_outputs __pyx_string_tab[677] +#define __pyx_n_u_outputs_valid __pyx_string_tab[678] +#define __pyx_n_u_outquadrature __pyx_string_tab[679] +#define __pyx_n_u_outreal __pyx_string_tab[680] +#define __pyx_n_u_outreallowerband __pyx_string_tab[681] +#define __pyx_n_u_outrealmiddleband __pyx_string_tab[682] +#define __pyx_n_u_outrealupperband __pyx_string_tab[683] +#define __pyx_n_u_outsine __pyx_string_tab[684] +#define __pyx_n_u_outslowd __pyx_string_tab[685] +#define __pyx_n_u_outslowk __pyx_string_tab[686] +#define __pyx_n_u_pandas __pyx_string_tab[687] +#define __pyx_n_u_param __pyx_string_tab[688] +#define __pyx_n_u_param_name __pyx_string_tab[689] +#define __pyx_n_u_parameters __pyx_string_tab[690] +#define __pyx_n_u_params __pyx_string_tab[691] +#define __pyx_n_u_penetration __pyx_string_tab[692] +#define __pyx_n_u_period __pyx_string_tab[693] +#define __pyx_n_u_periods __pyx_string_tab[694] +#define __pyx_n_u_periods_data __pyx_string_tab[695] +#define __pyx_n_u_polars __pyx_string_tab[696] +#define __pyx_n_u_pop __pyx_string_tab[697] +#define __pyx_n_u_prepare __pyx_string_tab[698] +#define __pyx_n_u_price __pyx_string_tab[699] +#define __pyx_n_u_price0 __pyx_string_tab[700] +#define __pyx_n_u_price1 __pyx_string_tab[701] +#define __pyx_n_u_price_series __pyx_string_tab[702] +#define __pyx_n_u_price_series_name_values __pyx_string_tab[703] +#define __pyx_n_u_prices __pyx_string_tab[704] +#define __pyx_n_u_property __pyx_string_tab[705] +#define __pyx_n_u_qualname __pyx_string_tab[706] +#define __pyx_n_u_rangetype __pyx_string_tab[707] +#define __pyx_n_u_real __pyx_string_tab[708] +#define __pyx_n_u_real0 __pyx_string_tab[709] +#define __pyx_n_u_real0_data __pyx_string_tab[710] +#define __pyx_n_u_real1 __pyx_string_tab[711] +#define __pyx_n_u_real1_data __pyx_string_tab[712] +#define __pyx_n_u_real_data __pyx_string_tab[713] +#define __pyx_n_u_replace __pyx_string_tab[714] +#define __pyx_n_u_repr __pyx_string_tab[715] +#define __pyx_n_u_results __pyx_string_tab[716] +#define __pyx_n_u_ret __pyx_string_tab[717] +#define __pyx_n_u_retCode __pyx_string_tab[718] +#define __pyx_n_u_ret_code __pyx_string_tab[719] +#define __pyx_n_u_run __pyx_string_tab[720] +#define __pyx_n_u_s __pyx_string_tab[721] +#define __pyx_n_u_schema __pyx_string_tab[722] +#define __pyx_n_u_self __pyx_string_tab[723] +#define __pyx_n_u_series __pyx_string_tab[724] +#define __pyx_n_u_set_function_args __pyx_string_tab[725] +#define __pyx_n_u_set_input_arrays __pyx_string_tab[726] +#define __pyx_n_u_set_input_names __pyx_string_tab[727] +#define __pyx_n_u_set_name __pyx_string_tab[728] +#define __pyx_n_u_set_parameters __pyx_string_tab[729] +#define __pyx_n_u_setdefault __pyx_string_tab[730] +#define __pyx_n_u_settingtype __pyx_string_tab[731] +#define __pyx_n_u_signalmatype __pyx_string_tab[732] +#define __pyx_n_u_signalperiod __pyx_string_tab[733] +#define __pyx_n_u_skip_first __pyx_string_tab[734] +#define __pyx_n_u_slowd_matype __pyx_string_tab[735] +#define __pyx_n_u_slowd_period __pyx_string_tab[736] +#define __pyx_n_u_slowk_matype __pyx_string_tab[737] +#define __pyx_n_u_slowk_period __pyx_string_tab[738] +#define __pyx_n_u_slowlimit __pyx_string_tab[739] +#define __pyx_n_u_slowmatype __pyx_string_tab[740] +#define __pyx_n_u_slowperiod __pyx_string_tab[741] +#define __pyx_n_u_startvalue __pyx_string_tab[742] +#define __pyx_n_u_str __pyx_string_tab[743] +#define __pyx_n_u_str2bytes __pyx_string_tab[744] +#define __pyx_n_u_stream_ACCBANDS __pyx_string_tab[745] +#define __pyx_n_u_stream_ACOS __pyx_string_tab[746] +#define __pyx_n_u_stream_AD __pyx_string_tab[747] +#define __pyx_n_u_stream_ADD __pyx_string_tab[748] +#define __pyx_n_u_stream_ADOSC __pyx_string_tab[749] +#define __pyx_n_u_stream_ADX __pyx_string_tab[750] +#define __pyx_n_u_stream_ADXR __pyx_string_tab[751] +#define __pyx_n_u_stream_APO __pyx_string_tab[752] +#define __pyx_n_u_stream_AROON __pyx_string_tab[753] +#define __pyx_n_u_stream_AROONOSC __pyx_string_tab[754] +#define __pyx_n_u_stream_ASIN __pyx_string_tab[755] +#define __pyx_n_u_stream_ATAN __pyx_string_tab[756] +#define __pyx_n_u_stream_ATR __pyx_string_tab[757] +#define __pyx_n_u_stream_AVGDEV __pyx_string_tab[758] +#define __pyx_n_u_stream_AVGPRICE __pyx_string_tab[759] +#define __pyx_n_u_stream_BBANDS __pyx_string_tab[760] +#define __pyx_n_u_stream_BETA __pyx_string_tab[761] +#define __pyx_n_u_stream_BOP __pyx_string_tab[762] +#define __pyx_n_u_stream_CCI __pyx_string_tab[763] +#define __pyx_n_u_stream_CDL2CROWS __pyx_string_tab[764] +#define __pyx_n_u_stream_CDL3BLACKCROWS __pyx_string_tab[765] +#define __pyx_n_u_stream_CDL3INSIDE __pyx_string_tab[766] +#define __pyx_n_u_stream_CDL3LINESTRIKE __pyx_string_tab[767] +#define __pyx_n_u_stream_CDL3OUTSIDE __pyx_string_tab[768] +#define __pyx_n_u_stream_CDL3STARSINSOUTH __pyx_string_tab[769] +#define __pyx_n_u_stream_CDL3WHITESOLDIERS __pyx_string_tab[770] +#define __pyx_n_u_stream_CDLABANDONEDBABY __pyx_string_tab[771] +#define __pyx_n_u_stream_CDLADVANCEBLOCK __pyx_string_tab[772] +#define __pyx_n_u_stream_CDLBELTHOLD __pyx_string_tab[773] +#define __pyx_n_u_stream_CDLBREAKAWAY __pyx_string_tab[774] +#define __pyx_n_u_stream_CDLCLOSINGMARUBOZU __pyx_string_tab[775] +#define __pyx_n_u_stream_CDLCONCEALBABYSWALL __pyx_string_tab[776] +#define __pyx_n_u_stream_CDLCOUNTERATTACK __pyx_string_tab[777] +#define __pyx_n_u_stream_CDLDARKCLOUDCOVER __pyx_string_tab[778] +#define __pyx_n_u_stream_CDLDOJI __pyx_string_tab[779] +#define __pyx_n_u_stream_CDLDOJISTAR __pyx_string_tab[780] +#define __pyx_n_u_stream_CDLDRAGONFLYDOJI __pyx_string_tab[781] +#define __pyx_n_u_stream_CDLENGULFING __pyx_string_tab[782] +#define __pyx_n_u_stream_CDLEVENINGDOJISTAR __pyx_string_tab[783] +#define __pyx_n_u_stream_CDLEVENINGSTAR __pyx_string_tab[784] +#define __pyx_n_u_stream_CDLGAPSIDESIDEWHITE __pyx_string_tab[785] +#define __pyx_n_u_stream_CDLGRAVESTONEDOJI __pyx_string_tab[786] +#define __pyx_n_u_stream_CDLHAMMER __pyx_string_tab[787] +#define __pyx_n_u_stream_CDLHANGINGMAN __pyx_string_tab[788] +#define __pyx_n_u_stream_CDLHARAMI __pyx_string_tab[789] +#define __pyx_n_u_stream_CDLHARAMICROSS __pyx_string_tab[790] +#define __pyx_n_u_stream_CDLHIGHWAVE __pyx_string_tab[791] +#define __pyx_n_u_stream_CDLHIKKAKE __pyx_string_tab[792] +#define __pyx_n_u_stream_CDLHIKKAKEMOD __pyx_string_tab[793] +#define __pyx_n_u_stream_CDLHOMINGPIGEON __pyx_string_tab[794] +#define __pyx_n_u_stream_CDLIDENTICAL3CROWS __pyx_string_tab[795] +#define __pyx_n_u_stream_CDLINNECK __pyx_string_tab[796] +#define __pyx_n_u_stream_CDLINVERTEDHAMMER __pyx_string_tab[797] +#define __pyx_n_u_stream_CDLKICKING __pyx_string_tab[798] +#define __pyx_n_u_stream_CDLKICKINGBYLENGTH __pyx_string_tab[799] +#define __pyx_n_u_stream_CDLLADDERBOTTOM __pyx_string_tab[800] +#define __pyx_n_u_stream_CDLLONGLEGGEDDOJI __pyx_string_tab[801] +#define __pyx_n_u_stream_CDLLONGLINE __pyx_string_tab[802] +#define __pyx_n_u_stream_CDLMARUBOZU __pyx_string_tab[803] +#define __pyx_n_u_stream_CDLMATCHINGLOW __pyx_string_tab[804] +#define __pyx_n_u_stream_CDLMATHOLD __pyx_string_tab[805] +#define __pyx_n_u_stream_CDLMORNINGDOJISTAR __pyx_string_tab[806] +#define __pyx_n_u_stream_CDLMORNINGSTAR __pyx_string_tab[807] +#define __pyx_n_u_stream_CDLONNECK __pyx_string_tab[808] +#define __pyx_n_u_stream_CDLPIERCING __pyx_string_tab[809] +#define __pyx_n_u_stream_CDLRICKSHAWMAN __pyx_string_tab[810] +#define __pyx_n_u_stream_CDLRISEFALL3METHODS __pyx_string_tab[811] +#define __pyx_n_u_stream_CDLSEPARATINGLINES __pyx_string_tab[812] +#define __pyx_n_u_stream_CDLSHOOTINGSTAR __pyx_string_tab[813] +#define __pyx_n_u_stream_CDLSHORTLINE __pyx_string_tab[814] +#define __pyx_n_u_stream_CDLSPINNINGTOP __pyx_string_tab[815] +#define __pyx_n_u_stream_CDLSTALLEDPATTERN __pyx_string_tab[816] +#define __pyx_n_u_stream_CDLSTICKSANDWICH __pyx_string_tab[817] +#define __pyx_n_u_stream_CDLTAKURI __pyx_string_tab[818] +#define __pyx_n_u_stream_CDLTASUKIGAP __pyx_string_tab[819] +#define __pyx_n_u_stream_CDLTHRUSTING __pyx_string_tab[820] +#define __pyx_n_u_stream_CDLTRISTAR __pyx_string_tab[821] +#define __pyx_n_u_stream_CDLUNIQUE3RIVER __pyx_string_tab[822] +#define __pyx_n_u_stream_CDLUPSIDEGAP2CROWS __pyx_string_tab[823] +#define __pyx_n_u_stream_CDLXSIDEGAP3METHODS __pyx_string_tab[824] +#define __pyx_n_u_stream_CEIL __pyx_string_tab[825] +#define __pyx_n_u_stream_CMO __pyx_string_tab[826] +#define __pyx_n_u_stream_CORREL __pyx_string_tab[827] +#define __pyx_n_u_stream_COS __pyx_string_tab[828] +#define __pyx_n_u_stream_COSH __pyx_string_tab[829] +#define __pyx_n_u_stream_DEMA __pyx_string_tab[830] +#define __pyx_n_u_stream_DIV __pyx_string_tab[831] +#define __pyx_n_u_stream_DX __pyx_string_tab[832] +#define __pyx_n_u_stream_EMA __pyx_string_tab[833] +#define __pyx_n_u_stream_EXP __pyx_string_tab[834] +#define __pyx_n_u_stream_FLOOR __pyx_string_tab[835] +#define __pyx_n_u_stream_HT_DCPERIOD __pyx_string_tab[836] +#define __pyx_n_u_stream_HT_DCPHASE __pyx_string_tab[837] +#define __pyx_n_u_stream_HT_PHASOR __pyx_string_tab[838] +#define __pyx_n_u_stream_HT_SINE __pyx_string_tab[839] +#define __pyx_n_u_stream_HT_TRENDLINE __pyx_string_tab[840] +#define __pyx_n_u_stream_HT_TRENDMODE __pyx_string_tab[841] +#define __pyx_n_u_stream_IMI __pyx_string_tab[842] +#define __pyx_n_u_stream_KAMA __pyx_string_tab[843] +#define __pyx_n_u_stream_LINEARREG __pyx_string_tab[844] +#define __pyx_n_u_stream_LINEARREG_ANGLE __pyx_string_tab[845] +#define __pyx_n_u_stream_LINEARREG_INTERCEPT __pyx_string_tab[846] +#define __pyx_n_u_stream_LINEARREG_SLOPE __pyx_string_tab[847] +#define __pyx_n_u_stream_LN __pyx_string_tab[848] +#define __pyx_n_u_stream_LOG10 __pyx_string_tab[849] +#define __pyx_n_u_stream_MA __pyx_string_tab[850] +#define __pyx_n_u_stream_MACD __pyx_string_tab[851] +#define __pyx_n_u_stream_MACDEXT __pyx_string_tab[852] +#define __pyx_n_u_stream_MACDFIX __pyx_string_tab[853] +#define __pyx_n_u_stream_MAMA __pyx_string_tab[854] +#define __pyx_n_u_stream_MAVP __pyx_string_tab[855] +#define __pyx_n_u_stream_MAX __pyx_string_tab[856] +#define __pyx_n_u_stream_MAXINDEX __pyx_string_tab[857] +#define __pyx_n_u_stream_MEDPRICE __pyx_string_tab[858] +#define __pyx_n_u_stream_MFI __pyx_string_tab[859] +#define __pyx_n_u_stream_MIDPOINT __pyx_string_tab[860] +#define __pyx_n_u_stream_MIDPRICE __pyx_string_tab[861] +#define __pyx_n_u_stream_MIN __pyx_string_tab[862] +#define __pyx_n_u_stream_MININDEX __pyx_string_tab[863] +#define __pyx_n_u_stream_MINMAX __pyx_string_tab[864] +#define __pyx_n_u_stream_MINMAXINDEX __pyx_string_tab[865] +#define __pyx_n_u_stream_MINUS_DI __pyx_string_tab[866] +#define __pyx_n_u_stream_MINUS_DM __pyx_string_tab[867] +#define __pyx_n_u_stream_MOM __pyx_string_tab[868] +#define __pyx_n_u_stream_MULT __pyx_string_tab[869] +#define __pyx_n_u_stream_NATR __pyx_string_tab[870] +#define __pyx_n_u_stream_OBV __pyx_string_tab[871] +#define __pyx_n_u_stream_PLUS_DI __pyx_string_tab[872] +#define __pyx_n_u_stream_PLUS_DM __pyx_string_tab[873] +#define __pyx_n_u_stream_PPO __pyx_string_tab[874] +#define __pyx_n_u_stream_ROC __pyx_string_tab[875] +#define __pyx_n_u_stream_ROCP __pyx_string_tab[876] +#define __pyx_n_u_stream_ROCR __pyx_string_tab[877] +#define __pyx_n_u_stream_ROCR100 __pyx_string_tab[878] +#define __pyx_n_u_stream_RSI __pyx_string_tab[879] +#define __pyx_n_u_stream_SAR __pyx_string_tab[880] +#define __pyx_n_u_stream_SAREXT __pyx_string_tab[881] +#define __pyx_n_u_stream_SIN __pyx_string_tab[882] +#define __pyx_n_u_stream_SINH __pyx_string_tab[883] +#define __pyx_n_u_stream_SMA __pyx_string_tab[884] +#define __pyx_n_u_stream_SQRT __pyx_string_tab[885] +#define __pyx_n_u_stream_STDDEV __pyx_string_tab[886] +#define __pyx_n_u_stream_STOCH __pyx_string_tab[887] +#define __pyx_n_u_stream_STOCHF __pyx_string_tab[888] +#define __pyx_n_u_stream_STOCHRSI __pyx_string_tab[889] +#define __pyx_n_u_stream_SUB __pyx_string_tab[890] +#define __pyx_n_u_stream_SUM __pyx_string_tab[891] +#define __pyx_n_u_stream_T3 __pyx_string_tab[892] +#define __pyx_n_u_stream_TAN __pyx_string_tab[893] +#define __pyx_n_u_stream_TANH __pyx_string_tab[894] +#define __pyx_n_u_stream_TEMA __pyx_string_tab[895] +#define __pyx_n_u_stream_TRANGE __pyx_string_tab[896] +#define __pyx_n_u_stream_TRIMA __pyx_string_tab[897] +#define __pyx_n_u_stream_TRIX __pyx_string_tab[898] +#define __pyx_n_u_stream_TSF __pyx_string_tab[899] +#define __pyx_n_u_stream_TYPPRICE __pyx_string_tab[900] +#define __pyx_n_u_stream_ULTOSC __pyx_string_tab[901] +#define __pyx_n_u_stream_VAR __pyx_string_tab[902] +#define __pyx_n_u_stream_WCLPRICE __pyx_string_tab[903] +#define __pyx_n_u_stream_WILLR __pyx_string_tab[904] +#define __pyx_n_u_stream_WMA __pyx_string_tab[905] +#define __pyx_n_u_sys __pyx_string_tab[906] +#define __pyx_n_u_ta_check_success __pyx_string_tab[907] +#define __pyx_n_u_ta_func_unst_ids __pyx_string_tab[908] +#define __pyx_n_u_ta_getFuncInfo __pyx_string_tab[909] +#define __pyx_n_u_ta_getFuncTable __pyx_string_tab[910] +#define __pyx_n_u_ta_getGroupTable __pyx_string_tab[911] +#define __pyx_n_u_ta_getInputParameterInfo __pyx_string_tab[912] +#define __pyx_n_u_ta_getOptInputParameterInfo __pyx_string_tab[913] +#define __pyx_n_u_ta_getOutputParameterInfo __pyx_string_tab[914] +#define __pyx_n_u_ta_get_compatibility __pyx_string_tab[915] +#define __pyx_n_u_ta_get_unstable_period __pyx_string_tab[916] +#define __pyx_n_u_ta_initialize __pyx_string_tab[917] +#define __pyx_n_u_ta_restore_candle_default_setti __pyx_string_tab[918] +#define __pyx_n_u_ta_set_candle_settings __pyx_string_tab[919] +#define __pyx_n_u_ta_set_compatibility __pyx_string_tab[920] +#define __pyx_n_u_ta_set_unstable_period __pyx_string_tab[921] +#define __pyx_n_u_ta_shutdown __pyx_string_tab[922] +#define __pyx_n_u_ta_version __pyx_string_tab[923] +#define __pyx_n_u_table __pyx_string_tab[924] +#define __pyx_n_u_talib__ta_lib __pyx_string_tab[925] +#define __pyx_n_u_test __pyx_string_tab[926] +#define __pyx_n_u_threading __pyx_string_tab[927] +#define __pyx_n_u_timeStamp __pyx_string_tab[928] +#define __pyx_n_u_timeperiod __pyx_string_tab[929] +#define __pyx_n_u_timeperiod1 __pyx_string_tab[930] +#define __pyx_n_u_timeperiod2 __pyx_string_tab[931] +#define __pyx_n_u_timeperiod3 __pyx_string_tab[932] +#define __pyx_n_u_to_numpy __pyx_string_tab[933] +#define __pyx_n_u_type __pyx_string_tab[934] +#define __pyx_n_u_type_2 __pyx_string_tab[935] +#define __pyx_n_u_unicode __pyx_string_tab[936] +#define __pyx_n_u_update __pyx_string_tab[937] +#define __pyx_n_u_update_info __pyx_string_tab[938] +#define __pyx_n_u_upper __pyx_string_tab[939] +#define __pyx_n_u_value __pyx_string_tab[940] +#define __pyx_n_u_value_range __pyx_string_tab[941] +#define __pyx_n_u_values __pyx_string_tab[942] +#define __pyx_n_u_version __pyx_string_tab[943] +#define __pyx_n_u_vfactor __pyx_string_tab[944] +#define __pyx_n_u_volume __pyx_string_tab[945] +#define __pyx_n_u_volume_data __pyx_string_tab[946] +#define __pyx_kp_b_iso88591_01_aq_Q_T_q_RvXRt6_4_S_aammnn_Q __pyx_string_tab[947] +#define __pyx_kp_b_iso88591_01_aq_Q_T_q_a_RvXRt6_4_S_aammnn __pyx_string_tab[948] +#define __pyx_kp_b_iso88591_01_aq_T_q_8_T_U_7_A_we_7r_q_Bd __pyx_string_tab[949] +#define __pyx_kp_b_iso88591_0HHbb_0_aq_Q_T_q_q_q_RvXRt6_4_S __pyx_string_tab[950] +#define __pyx_kp_b_iso88591_0_aq_Q_T_q_a_A_BfHBd_lRaabbnnoo __pyx_string_tab[951] +#define __pyx_kp_b_iso88591_0_aq_Q_T_q_a_BfHBd_lR___llmm_Qn __pyx_string_tab[952] +#define __pyx_kp_b_iso88591_12_aq_Q_T_q_a_b_hb_F_D_Taabbnno __pyx_string_tab[953] +#define __pyx_kp_b_iso88591_1_1 __pyx_string_tab[954] +#define __pyx_kp_b_iso88591_1_a_OuTUUV_Q_31_9AT_4q_1HF_wc_d __pyx_string_tab[955] +#define __pyx_kp_b_iso88591_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk __pyx_string_tab[956] +#define __pyx_kp_b_iso88591_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk_2 __pyx_string_tab[957] +#define __pyx_kp_b_iso88591_2_1_Q_9 __pyx_string_tab[958] +#define __pyx_kp_b_iso88591_314DAQ_Q_a_4q_a_Qd_c_a_Qd_s_4q __pyx_string_tab[959] +#define __pyx_kp_b_iso88591_34_aq_Q_T_q_fHBd_Vccddppq_r_A_A __pyx_string_tab[960] +#define __pyx_kp_b_iso88591_45_aq_T_q_8_T_U_7_A_we_2Q_q_i_f __pyx_string_tab[961] +#define __pyx_kp_b_iso88591_5_t_Qm1_d_1_c_d_3a_Q_c_d_3a_Q_u __pyx_string_tab[962] +#define __pyx_kp_b_iso88591_78_aq_Q_T_q_a_BfHBd_lZgghhttu_v __pyx_string_tab[963] +#define __pyx_kp_b_iso88591_A2_A_QnA_1_t_6a_gQ_d_Q_d_1_q_s_A __pyx_string_tab[964] +#define __pyx_kp_b_iso88591_AA_uuv0_aq_T_q_8_T_U_7_A_we_0_o __pyx_string_tab[965] +#define __pyx_kp_b_iso88591_A_A_1_N_q_5_A_z_HA_G1A_q_q __pyx_string_tab[966] +#define __pyx_kp_b_iso88591_A_A_2_k_Qa_e_e1_2S_AQ_U_t1A_q_4 __pyx_string_tab[967] +#define __pyx_kp_b_iso88591_A_A_4_B_q_A_U_q_we1_axq_wgQa_Q_a __pyx_string_tab[968] +#define __pyx_kp_b_iso88591_A_A_4uA_e87_4z_q_aq_gU_5_q_E_a_s __pyx_string_tab[969] +#define __pyx_kp_b_iso88591_A_A_4wawa_1_Kq_Q_V1E_d_1_0_Ya_T __pyx_string_tab[970] +#define __pyx_kp_b_iso88591_A_A_6_6_6_7_7_81_7_7_5 __pyx_string_tab[971] +#define __pyx_kp_b_iso88591_A_A_AQ_6_A_E_A_q __pyx_string_tab[972] +#define __pyx_kp_b_iso88591_A_A_L_6_Qk_A_a_QnA_a __pyx_string_tab[973] +#define __pyx_kp_b_iso88591_A_A_a_G1_t3e1_aq_4_q_Q_AT_V1A_S __pyx_string_tab[974] +#define __pyx_kp_b_iso88591_A_A_at1_C_IQe1_D_aq_E_AZq_vV_2_V __pyx_string_tab[975] +#define __pyx_kp_b_iso88591_A_A_gQ_5_q_5_V1_5_U __pyx_string_tab[976] +#define __pyx_kp_b_iso88591_A_A_k_M_a_q_T_7q_q __pyx_string_tab[977] +#define __pyx_kp_b_iso88591_A_A_k_N_q_q_e_q_1A_q __pyx_string_tab[978] +#define __pyx_kp_b_iso88591_A_B_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d __pyx_string_tab[979] +#define __pyx_kp_b_iso88591_A_HKq_1A_6_5Q_A_7_4A_A_QgQ_7_1_A __pyx_string_tab[980] +#define __pyx_kp_b_iso88591_A_Jm6_M_Q_Jiq_A_O9F_b_O1 __pyx_string_tab[981] +#define __pyx_kp_b_iso88591_A_Qd __pyx_string_tab[982] +#define __pyx_kp_b_iso88591_A_Y_Y_Z_aq_Q_Qa_y_1_Kq_q_6_6_gQ __pyx_string_tab[983] +#define __pyx_kp_b_iso88591_A_aq_Kq_6_8_T_5_U_7_A_we_2Q_q_i __pyx_string_tab[984] +#define __pyx_kp_b_iso88591_A_aq_Qa_6_8_T_3a_U_7_A_we_Rq_AX __pyx_string_tab[985] +#define __pyx_kp_b_iso88591_A_aq_T_q_8_T_U_7_A_we_2_q_i_fAY __pyx_string_tab[986] +#define __pyx_kp_b_iso88591_A_d_q_4z_q_aq_q __pyx_string_tab[987] +#define __pyx_kp_b_iso88591_A_q __pyx_string_tab[988] +#define __pyx_kp_b_iso88591_A_q_q __pyx_string_tab[989] +#define __pyx_kp_b_iso88591_A_t81A __pyx_string_tab[990] +#define __pyx_kp_b_iso88591_A_t85 __pyx_string_tab[991] +#define __pyx_kp_b_iso88591_A_t85_Q __pyx_string_tab[992] +#define __pyx_kp_b_iso88591_A_t85_Q_2 __pyx_string_tab[993] +#define __pyx_kp_b_iso88591_A_uAS __pyx_string_tab[994] +#define __pyx_kp_b_iso88591_A_uBd __pyx_string_tab[995] +#define __pyx_kp_b_iso88591_A_wat81 __pyx_string_tab[996] +#define __pyx_kp_b_iso88591_A_z_____b_b_G_G_h_h_i_4_aq_Qa_6 __pyx_string_tab[997] +#define __pyx_kp_b_iso88591_BC_Kq_Kq_7_8_U_E_U_7_A_we_Ba_q __pyx_string_tab[998] +#define __pyx_kp_b_iso88591_BC_aq_Qa_6_8_T_3a_U_7_A_we_r_q __pyx_string_tab[999] +#define __pyx_kp_b_iso88591_B_aq_Q_T_q_a_r_xr_V82T_Zccddppq __pyx_string_tab[1000] +#define __pyx_kp_b_iso88591_B_aq_Q_T_q_a_r_xr_V82T_Zddeeqqr __pyx_string_tab[1001] +#define __pyx_kp_b_iso88591_C1_aq_Q_T_q_a_fHBd_m_ccddppq_r __pyx_string_tab[1002] +#define __pyx_kp_b_iso88591_CC_aq_Q_T_q_a_fHBd_m_hhqqrr_O_O __pyx_string_tab[1003] +#define __pyx_kp_b_iso88591_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q __pyx_string_tab[1004] +#define __pyx_kp_b_iso88591_CZZqqr_aq_k_6_8_T_7_U_7_A_we_Bl __pyx_string_tab[1005] +#define __pyx_kp_b_iso88591_C_D_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d __pyx_string_tab[1006] +#define __pyx_kp_b_iso88591_DD_2_aq_Q_T_q_a_A_6_4vXRt_iixxy __pyx_string_tab[1007] +#define __pyx_kp_b_iso88591_DE_Kq_Kq_7_8_U_E_U_7_A_we_b_q_2 __pyx_string_tab[1008] +#define __pyx_kp_b_iso88591_D_E_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA __pyx_string_tab[1009] +#define __pyx_kp_b_iso88591_D_E_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d __pyx_string_tab[1010] +#define __pyx_kp_b_iso88591_EQ_aq_Q_T_q_a_a_6_4vXRt_gghhttu __pyx_string_tab[1011] +#define __pyx_kp_b_iso88591_E_F_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d __pyx_string_tab[1012] +#define __pyx_kp_b_iso88591_E_a_aq_Q_Qa_y_1_6_a_fHBd_kYhhrr __pyx_string_tab[1013] +#define __pyx_kp_b_iso88591_FF_ttu4_aq_Q_T_q_q_q_2V82T_xr_Q __pyx_string_tab[1014] +#define __pyx_kp_b_iso88591_Fa_aq_Q_T_q_a_2V82T_xr_Q_ffggss __pyx_string_tab[1015] +#define __pyx_kp_b_iso88591_GGZZr_s_F_F_a_8_aq_Q_T_q_a_A_Bf __pyx_string_tab[1016] +#define __pyx_kp_b_iso88591_GH_aq_Q_Kq_q_6_a_fHBd_m_hhiiuuv __pyx_string_tab[1017] +#define __pyx_kp_b_iso88591_GH_aq_Q_Qa_y_1_6_1_F_D_hb_LP_hh __pyx_string_tab[1018] +#define __pyx_kp_b_iso88591_H_I_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA __pyx_string_tab[1019] +#define __pyx_kp_b_iso88591_Hb_c_B_B_f_f_F_F_i_i_N_N_o_o_p __pyx_string_tab[1020] +#define __pyx_kp_b_iso88591_IJ_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkk __pyx_string_tab[1021] +#define __pyx_kp_b_iso88591_IJ_aq_Q_Qa_y_1_6_a_BfHBd_lR_jjk __pyx_string_tab[1022] +#define __pyx_kp_b_iso88591_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k __pyx_string_tab[1023] +#define __pyx_kp_b_iso88591_J_K_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA __pyx_string_tab[1024] +#define __pyx_kp_b_iso88591_Jaaxxy_aq_Q_k_9G1_6_a_6_4vXRt_j __pyx_string_tab[1025] +#define __pyx_kp_b_iso88591_KL_Kq_q_Kq_q_7_a_2V82T_xr_R__ll __pyx_string_tab[1026] +#define __pyx_kp_b_iso88591_K_L_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA __pyx_string_tab[1027] +#define __pyx_kp_b_iso88591_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ __pyx_string_tab[1028] +#define __pyx_kp_b_iso88591_Kq_Kq_7_8_U_E_U_7_A_we_A_q_4y_5 __pyx_string_tab[1029] +#define __pyx_kp_b_iso88591_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkkzz __pyx_string_tab[1030] +#define __pyx_kp_b_iso88591_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj __pyx_string_tab[1031] +#define __pyx_kp_b_iso88591_L_M_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA __pyx_string_tab[1032] +#define __pyx_kp_b_iso88591_N_1_A_t1 __pyx_string_tab[1033] +#define __pyx_kp_b_iso88591_Q_AQQVVWWX_Q_5Q_9AT_4q_1JfA_Cq __pyx_string_tab[1034] +#define __pyx_kp_b_iso88591_Q_A_1_G9JfA_t_1G1_q_1_a_U_4q __pyx_string_tab[1035] +#define __pyx_kp_b_iso88591_Q_B_1A_Q_V1E_gQfAU_Q_1 __pyx_string_tab[1036] +#define __pyx_kp_b_iso88591_Q_NeSTTU_Q_2_9AT_4q_1G6_wc_t81H __pyx_string_tab[1037] +#define __pyx_kp_b_iso88591_Q_V1E_q_WAQ_Q_aq_1 __pyx_string_tab[1038] +#define __pyx_kp_b_iso88591_Q_q __pyx_string_tab[1039] +#define __pyx_kp_b_iso88591_Qa_Qa_1 __pyx_string_tab[1040] +#define __pyx_kp_b_iso88591_Qa_q_A_Q_a __pyx_string_tab[1041] +#define __pyx_kp_b_iso88591_SSkk_Y_Y_Z_8_aq_T_q_8_T_U_7_A_w __pyx_string_tab[1042] +#define __pyx_kp_b_iso88591_TTU_aq_T_q_8_T_U_7_A_we_2_q_q_i __pyx_string_tab[1043] +#define __pyx_kp_b_iso88591_UUV2_aq_T_q_8_T_U_7_A_we_Bm_q_Q __pyx_string_tab[1044] +#define __pyx_kp_b_iso88591_VVmmn4_aq_T_q_8_T_U_7_A_we_b_Zz __pyx_string_tab[1045] +#define __pyx_kp_b_iso88591_YYZ_aq_Qa_6_8_T_3a_U_7_A_we_2_A __pyx_string_tab[1046] +#define __pyx_kp_b_iso88591_YZ_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A __pyx_string_tab[1047] +#define __pyx_kp_b_iso88591_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w __pyx_string_tab[1048] +#define __pyx_kp_b_iso88591_a_QoQ __pyx_string_tab[1049] +#define __pyx_kp_b_iso88591_a_aq_Q_Qa_y_1_Kq_q_6_a_a_r_xr_V __pyx_string_tab[1050] +#define __pyx_kp_b_iso88591_a_aq_T_q_8_T_U_7_A_we_Bl_q_q_4y __pyx_string_tab[1051] +#define __pyx_kp_b_iso88591_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd __pyx_string_tab[1052] +#define __pyx_kp_b_iso88591_aq_6_8_T_6_U_7_A_we_1_q_i_fAYkQ __pyx_string_tab[1053] +#define __pyx_kp_b_iso88591_aq_Q_6_6_a_fHBd_n_iijjyyzz_Qj_1 __pyx_string_tab[1054] +#define __pyx_kp_b_iso88591_aq_Q_Q __pyx_string_tab[1055] +#define __pyx_kp_b_iso88591_aq_Q_Qa_y_1_6_a_RvXRt6_4_S___kk __pyx_string_tab[1056] +#define __pyx_kp_b_iso88591_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_fHBd __pyx_string_tab[1057] +#define __pyx_kp_b_iso88591_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_r_xr __pyx_string_tab[1058] +#define __pyx_kp_b_iso88591_aq_Q_Qa_y_1_Kq_q_6_a_a_2V82T_xr __pyx_string_tab[1059] +#define __pyx_kp_b_iso88591_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt6_4 __pyx_string_tab[1060] +#define __pyx_kp_b_iso88591_aq_Q_T_q_6_4vXRt_WXXddeettuuv_Q __pyx_string_tab[1061] +#define __pyx_kp_b_iso88591_aq_Q_T_q_A_b_hb_F_D_TUUaabbqqrr __pyx_string_tab[1062] +#define __pyx_kp_b_iso88591_aq_Q_T_q_Q_Q_2V82T_xr_Q___kkll __pyx_string_tab[1063] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_2V82T_xr_Q___kkll_Qm __pyx_string_tab[1064] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_WXXddeettuuv __pyx_string_tab[1065] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk __pyx_string_tab[1066] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk __pyx_string_tab[1067] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_BfHBd_lRSS___ooppzz __pyx_string_tab[1068] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_F_D_hb_LPQQ_mmnno_Ql __pyx_string_tab[1069] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_F_D_hb_LP_jjkkzz_Ql __pyx_string_tab[1070] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_fHBdR_kkllxxy_z_I_I __pyx_string_tab[1071] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_VWWccddssttu_Q __pyx_string_tab[1072] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1 __pyx_string_tab[1073] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj __pyx_string_tab[1074] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_r_xr_V82T_QlZ_jjkkl __pyx_string_tab[1075] +#define __pyx_kp_b_iso88591_aq_Q_T_q_a_r_xr_V82T_UVVbbccrrs __pyx_string_tab[1076] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82 __pyx_string_tab[1077] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v __pyx_string_tab[1078] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB __pyx_string_tab[1079] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB_2 __pyx_string_tab[1080] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_F_D __pyx_string_tab[1081] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR __pyx_string_tab[1082] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_Rv __pyx_string_tab[1083] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_fH __pyx_string_tab[1084] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb __pyx_string_tab[1085] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2 __pyx_string_tab[1086] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd __pyx_string_tab[1087] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2 __pyx_string_tab[1088] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr __pyx_string_tab[1089] +#define __pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2 __pyx_string_tab[1090] +#define __pyx_kp_b_iso88591_aq_Qa_6_8_T_3a_U_7_A_we_0_q_Rt9 __pyx_string_tab[1091] +#define __pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w __pyx_string_tab[1092] +#define __pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_2 __pyx_string_tab[1093] +#define __pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_3 __pyx_string_tab[1094] +#define __pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we __pyx_string_tab[1095] +#define __pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_2 __pyx_string_tab[1096] +#define __pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_3 __pyx_string_tab[1097] +#define __pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_4 __pyx_string_tab[1098] +#define __pyx_kp_b_iso88591_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoouuv __pyx_string_tab[1099] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6 __pyx_string_tab[1100] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6_2 __pyx_string_tab[1101] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_1_1_q_b_I_F __pyx_string_tab[1102] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_1_81_Qha_b __pyx_string_tab[1103] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa __pyx_string_tab[1104] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm __pyx_string_tab[1105] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2_q_r_Yk_V1 __pyx_string_tab[1106] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_31_q_i_fAYa __pyx_string_tab[1107] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_32Q_axq_axq __pyx_string_tab[1108] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ __pyx_string_tab[1109] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ_2 __pyx_string_tab[1110] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi __pyx_string_tab[1111] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ __pyx_string_tab[1112] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Q_q_D_D_ay __pyx_string_tab[1113] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Rq_q_D_D_ay __pyx_string_tab[1114] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_b_axq_axq_2 __pyx_string_tab[1115] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_b_q_2T_T_q __pyx_string_tab[1116] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_q_q_1HA_Bd __pyx_string_tab[1117] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_q_r_Yk_V1IQ __pyx_string_tab[1118] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_r_q_Bd_d_WX __pyx_string_tab[1119] +#define __pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_r_q_Qha_1HA __pyx_string_tab[1120] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns __pyx_string_tab[1121] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10 __pyx_string_tab[1122] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11 __pyx_string_tab[1123] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12 __pyx_string_tab[1124] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_13 __pyx_string_tab[1125] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_14 __pyx_string_tab[1126] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_15 __pyx_string_tab[1127] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_2 __pyx_string_tab[1128] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3 __pyx_string_tab[1129] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4 __pyx_string_tab[1130] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5 __pyx_string_tab[1131] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6 __pyx_string_tab[1132] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7 __pyx_string_tab[1133] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8 __pyx_string_tab[1134] +#define __pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9 __pyx_string_tab[1135] +#define __pyx_kp_b_iso88591_bc_aq_Q_Qa_y_1_Kq_q_6_a_a_6_4vX __pyx_string_tab[1136] +#define __pyx_kp_b_iso88591_c_X_X_m_m_G_G_H_6_aq_Q_Qa_y_1_K __pyx_string_tab[1137] +#define __pyx_kp_b_iso88591_cd_aq_Q_Qa_y_1_Kq_q_6_a_a_F_D_h __pyx_string_tab[1138] +#define __pyx_kp_b_iso88591_d_W_W_X_aq_Q_Qa_y_1_Kq_q_6_a_a __pyx_string_tab[1139] +#define __pyx_kp_b_iso88591_d_Y_Y_Z_2_aq_Q_Qa_y_1_Kq_q_6_a __pyx_string_tab[1140] +#define __pyx_kp_b_iso88591_ef_aq_Q_Qa_y_1_Kq_q_6_a_a_BfHBd __pyx_string_tab[1141] +#define __pyx_kp_b_iso88591_fg2_aq_Q_Qa_y_1_Kq_q_6_a_q_q_Rv __pyx_string_tab[1142] +#define __pyx_kp_b_iso88591_fg_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt __pyx_string_tab[1143] +#define __pyx_kp_b_iso88591_q_1_Q_a __pyx_string_tab[1144] +#define __pyx_kp_b_iso88591_q_9A_1_q_1_1_1A_q_a_1A_4z_A_G1 __pyx_string_tab[1145] +#define __pyx_kp_b_iso88591_q_aq_T_q_8_T_U_7_A_we_b_Q_q_2T __pyx_string_tab[1146] +#define __pyx_kp_b_iso88591_v_w_P_P_Q_aq_Qa_Kq_6_a_8_T_3hjX __pyx_string_tab[1147] +#define __pyx_kp_b_iso88591_v_w_Q_Q_f_f_A_2_aq_Qa_Kq_6_a_8 __pyx_string_tab[1148] +#define __pyx_kp_b_iso88591_w_x_R_R_S_aq_Qa_Kq_6_a_8_T_3hjX __pyx_string_tab[1149] +#define __pyx_kp_b_iso88591_wx_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoou __pyx_string_tab[1150] +#define __pyx_kp_b_iso88591_y_1_q_Q_a_Q_a_Q_a_Q_a_Q_a_Q_a_Q __pyx_string_tab[1151] +#define __pyx_kp_b_iso88591_z_R_R_S_aq_Qa_Kq_6_gQ_8_T_3hjX __pyx_string_tab[1152] +#define __pyx_int_0 __pyx_number_tab[0] +#define __pyx_int_neg_1 __pyx_number_tab[1] +#define __pyx_int_1 __pyx_number_tab[2] +#define __pyx_int_2 __pyx_number_tab[3] +#define __pyx_int_3 __pyx_number_tab[4] +#define __pyx_int_4 __pyx_number_tab[5] +#define __pyx_int_8 __pyx_number_tab[6] +#define __pyx_int_9 __pyx_number_tab[7] +#define __pyx_int_12 __pyx_number_tab[8] +#define __pyx_int_16 __pyx_number_tab[9] +#define __pyx_int_32 __pyx_number_tab[10] +#define __pyx_int_64 __pyx_number_tab[11] +#define __pyx_int_128 __pyx_number_tab[12] +#define __pyx_int_256 __pyx_number_tab[13] +#define __pyx_int_512 __pyx_number_tab[14] +#define __pyx_int_1024 __pyx_number_tab[15] +#define __pyx_int_2048 __pyx_number_tab[16] +#define __pyx_int_4096 __pyx_number_tab[17] +#define __pyx_int_16777216 __pyx_number_tab[18] +#define __pyx_int_67108864 __pyx_number_tab[19] +#define __pyx_int_134217728 __pyx_number_tab[20] +#define __pyx_int_268435456 __pyx_number_tab[21] /* #### Code section: module_state_clear ### */ #if CYTHON_USE_MODULE_STATE -static int __pyx_m_clear(PyObject *m) { - __pyx_mstate *clear_module_state = __pyx_mstate(m); +static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { + __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); if (!clear_module_state) return 0; Py_CLEAR(clear_module_state->__pyx_d); Py_CLEAR(clear_module_state->__pyx_b); @@ -5554,11 +4579,8 @@ static int __pyx_m_clear(PyObject *m) { Py_CLEAR(clear_module_state->__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); + #if CYTHON_PEP489_MULTI_PHASE_INIT + __Pyx_State_RemoveModule(NULL); #endif Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_dtype); @@ -5576,1470 +4598,32 @@ static int __pyx_m_clear(PyObject *m) { Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flexible); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_character); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ufunc); - Py_CLEAR(clear_module_state->__pyx_kp_s_3); - Py_CLEAR(clear_module_state->__pyx_n_s_ACOS); - Py_CLEAR(clear_module_state->__pyx_n_s_AD); - Py_CLEAR(clear_module_state->__pyx_n_s_ADD); - Py_CLEAR(clear_module_state->__pyx_n_s_ADOSC); - Py_CLEAR(clear_module_state->__pyx_n_s_ADX); - Py_CLEAR(clear_module_state->__pyx_n_s_ADXR); - Py_CLEAR(clear_module_state->__pyx_n_s_ALL); - Py_CLEAR(clear_module_state->__pyx_n_s_APO); - Py_CLEAR(clear_module_state->__pyx_n_s_AROON); - Py_CLEAR(clear_module_state->__pyx_n_s_AROONOSC); - Py_CLEAR(clear_module_state->__pyx_n_s_ARRAY_TYPES); - Py_CLEAR(clear_module_state->__pyx_n_s_ASIN); - Py_CLEAR(clear_module_state->__pyx_n_s_ATAN); - Py_CLEAR(clear_module_state->__pyx_n_s_ATR); - Py_CLEAR(clear_module_state->__pyx_n_s_AVGPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_AllCandleSettings); - Py_CLEAR(clear_module_state->__pyx_kp_s_Allocation_Error_TA_ALLOC_ERR); - Py_CLEAR(clear_module_state->__pyx_n_s_BBANDS); - Py_CLEAR(clear_module_state->__pyx_n_s_BETA); - Py_CLEAR(clear_module_state->__pyx_n_s_BOP); - Py_CLEAR(clear_module_state->__pyx_kp_s_Bad_Object_TA_BAD_OBJECT); - Py_CLEAR(clear_module_state->__pyx_kp_s_Bad_Parameter_TA_BAD_PARAM); - Py_CLEAR(clear_module_state->__pyx_n_s_BodyDoji); - Py_CLEAR(clear_module_state->__pyx_n_s_BodyLong); - Py_CLEAR(clear_module_state->__pyx_n_s_BodyShort); - Py_CLEAR(clear_module_state->__pyx_n_s_BodyVeryLong); - Py_CLEAR(clear_module_state->__pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut); - Py_CLEAR(clear_module_state->__pyx_n_s_CCI); - Py_CLEAR(clear_module_state->__pyx_n_s_CDL2CROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_CDL3BLACKCROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_CDL3INSIDE); - Py_CLEAR(clear_module_state->__pyx_n_s_CDL3LINESTRIKE); - Py_CLEAR(clear_module_state->__pyx_n_s_CDL3OUTSIDE); - Py_CLEAR(clear_module_state->__pyx_n_s_CDL3STARSINSOUTH); - Py_CLEAR(clear_module_state->__pyx_n_s_CDL3WHITESOLDIERS); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLABANDONEDBABY); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLADVANCEBLOCK); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLBELTHOLD); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLBREAKAWAY); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLCLOSINGMARUBOZU); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLCONCEALBABYSWALL); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLCOUNTERATTACK); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLDARKCLOUDCOVER); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLDOJISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLDRAGONFLYDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLENGULFING); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLEVENINGDOJISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLEVENINGSTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLGAPSIDESIDEWHITE); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLGRAVESTONEDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLHAMMER); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLHANGINGMAN); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLHARAMI); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLHARAMICROSS); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLHIGHWAVE); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLHIKKAKE); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLHIKKAKEMOD); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLHOMINGPIGEON); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLIDENTICAL3CROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLINNECK); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLINVERTEDHAMMER); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLKICKING); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLKICKINGBYLENGTH); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLLADDERBOTTOM); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLLONGLEGGEDDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLLONGLINE); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLMARUBOZU); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLMATCHINGLOW); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLMATHOLD); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLMORNINGDOJISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLMORNINGSTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLONNECK); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLPIERCING); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLRICKSHAWMAN); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLRISEFALL3METHODS); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLSEPARATINGLINES); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLSHOOTINGSTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLSHORTLINE); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLSPINNINGTOP); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLSTALLEDPATTERN); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLSTICKSANDWICH); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLTAKURI); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLTASUKIGAP); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLTHRUSTING); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLTRISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLUNIQUE3RIVER); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLUPSIDEGAP2CROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_CDLXSIDEGAP3METHODS); - Py_CLEAR(clear_module_state->__pyx_n_s_CEIL); - Py_CLEAR(clear_module_state->__pyx_n_s_CMO); - Py_CLEAR(clear_module_state->__pyx_n_s_CORREL); - Py_CLEAR(clear_module_state->__pyx_n_s_COS); - Py_CLEAR(clear_module_state->__pyx_n_s_COSH); - Py_CLEAR(clear_module_state->__pyx_n_s_CandleSettingType); - Py_CLEAR(clear_module_state->__pyx_n_s_DEMA); - Py_CLEAR(clear_module_state->__pyx_n_s_DIV); - Py_CLEAR(clear_module_state->__pyx_n_s_DX); - Py_CLEAR(clear_module_state->__pyx_kp_s_Dashed_Line); - Py_CLEAR(clear_module_state->__pyx_n_s_DataFrame); - Py_CLEAR(clear_module_state->__pyx_n_s_Dot); - Py_CLEAR(clear_module_state->__pyx_kp_s_Dotted_Line); - Py_CLEAR(clear_module_state->__pyx_kp_s_Double_Exponential_Moving_Averag); - Py_CLEAR(clear_module_state->__pyx_n_s_EMA); - Py_CLEAR(clear_module_state->__pyx_n_s_EXP); - Py_CLEAR(clear_module_state->__pyx_n_s_Equal); - Py_CLEAR(clear_module_state->__pyx_kp_s_Exponential_Moving_Average); - Py_CLEAR(clear_module_state->__pyx_n_s_FLOOR); - Py_CLEAR(clear_module_state->__pyx_n_s_Far); - Py_CLEAR(clear_module_state->__pyx_n_s_Function); - Py_CLEAR(clear_module_state->__pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___call); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___call_function); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___check_opt_input_value); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___get_opt_input_value); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___init); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___input_price_series_na); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___local); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___repr); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___str); - Py_CLEAR(clear_module_state->__pyx_n_s_Function___unicode); - Py_CLEAR(clear_module_state->__pyx_n_s_Function__call_function); - Py_CLEAR(clear_module_state->__pyx_n_s_Function__check_opt_input_value); - Py_CLEAR(clear_module_state->__pyx_n_s_Function__get_opt_input_value); - Py_CLEAR(clear_module_state->__pyx_n_s_Function__input_price_series_na); - Py_CLEAR(clear_module_state->__pyx_n_s_Function__local); - Py_CLEAR(clear_module_state->__pyx_n_s_Function__localdata); - Py_CLEAR(clear_module_state->__pyx_n_s_Function__name); - Py_CLEAR(clear_module_state->__pyx_n_s_Function__namestr); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_function_flags); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_get_input_arrays); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_get_input_names); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_get_parameters); - Py_CLEAR(clear_module_state->__pyx_kp_s_Function_has_an_unstable_period); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_info); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_lookback); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_output_flags); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_output_names); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_outputs); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_run); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_set_function_args); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_set_input_arrays); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_set_input_names); - Py_CLEAR(clear_module_state->__pyx_n_s_Function_set_parameters); - Py_CLEAR(clear_module_state->__pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU); - Py_CLEAR(clear_module_state->__pyx_n_s_HT_DCPERIOD); - Py_CLEAR(clear_module_state->__pyx_n_s_HT_DCPHASE); - Py_CLEAR(clear_module_state->__pyx_n_s_HT_PHASOR); - Py_CLEAR(clear_module_state->__pyx_n_s_HT_SINE); - Py_CLEAR(clear_module_state->__pyx_n_s_HT_TRENDLINE); - Py_CLEAR(clear_module_state->__pyx_n_s_HT_TRENDMODE); - Py_CLEAR(clear_module_state->__pyx_n_s_HighLow); - Py_CLEAR(clear_module_state->__pyx_n_s_Histogram); - Py_CLEAR(clear_module_state->__pyx_n_s_INPUT_ARRAYS_TYPES); - Py_CLEAR(clear_module_state->__pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS); - Py_CLEAR(clear_module_state->__pyx_n_s_ImportError); - Py_CLEAR(clear_module_state->__pyx_n_s_IndexError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Input_Not_All_Initialized_TA_INP); - Py_CLEAR(clear_module_state->__pyx_kp_s_Inputs); - Py_CLEAR(clear_module_state->__pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR); - Py_CLEAR(clear_module_state->__pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE); - Py_CLEAR(clear_module_state->__pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS); - Py_CLEAR(clear_module_state->__pyx_kp_s_Invalid_Parameter_Function_TA_IN); - Py_CLEAR(clear_module_state->__pyx_kp_s_Invalid_Parameter_Holder_TA_INVA); - Py_CLEAR(clear_module_state->__pyx_kp_s_Invalid_Parameter_Holder_Type_TA); - Py_CLEAR(clear_module_state->__pyx_kp_s_Invalid_parameter_value_for_s_ex); - Py_CLEAR(clear_module_state->__pyx_n_s_KAMA); - Py_CLEAR(clear_module_state->__pyx_kp_s_Kaufman_Adaptive_Moving_Average); - Py_CLEAR(clear_module_state->__pyx_n_s_LINEARREG); - Py_CLEAR(clear_module_state->__pyx_n_s_LINEARREG_ANGLE); - Py_CLEAR(clear_module_state->__pyx_n_s_LINEARREG_INTERCEPT); - Py_CLEAR(clear_module_state->__pyx_n_s_LINEARREG_SLOPE); - Py_CLEAR(clear_module_state->__pyx_n_s_LN); - Py_CLEAR(clear_module_state->__pyx_n_s_LOG10); - Py_CLEAR(clear_module_state->__pyx_kp_s_Library_Not_Initialized_TA_LIB_N); - Py_CLEAR(clear_module_state->__pyx_n_s_Line); - Py_CLEAR(clear_module_state->__pyx_n_s_MA); - Py_CLEAR(clear_module_state->__pyx_n_s_MACD); - Py_CLEAR(clear_module_state->__pyx_n_s_MACDEXT); - Py_CLEAR(clear_module_state->__pyx_n_s_MACDFIX); - Py_CLEAR(clear_module_state->__pyx_n_s_MAMA); - Py_CLEAR(clear_module_state->__pyx_n_s_MAVP); - Py_CLEAR(clear_module_state->__pyx_n_s_MAX); - Py_CLEAR(clear_module_state->__pyx_n_s_MAXINDEX); - Py_CLEAR(clear_module_state->__pyx_n_s_MA_Type); - Py_CLEAR(clear_module_state->__pyx_n_s_MA_Type___getitem); - Py_CLEAR(clear_module_state->__pyx_n_s_MA_Type___init); - Py_CLEAR(clear_module_state->__pyx_n_s_MEDPRICE); - Py_CLEAR(clear_module_state->__pyx_kp_s_MESA_Adaptive_Moving_Average); - Py_CLEAR(clear_module_state->__pyx_n_s_MFI); - Py_CLEAR(clear_module_state->__pyx_n_s_MIDPOINT); - Py_CLEAR(clear_module_state->__pyx_n_s_MIDPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_MIN); - Py_CLEAR(clear_module_state->__pyx_n_s_MININDEX); - Py_CLEAR(clear_module_state->__pyx_n_s_MINMAX); - Py_CLEAR(clear_module_state->__pyx_n_s_MINMAXINDEX); - Py_CLEAR(clear_module_state->__pyx_n_s_MINUS_DI); - Py_CLEAR(clear_module_state->__pyx_n_s_MINUS_DM); - Py_CLEAR(clear_module_state->__pyx_n_s_MOM); - Py_CLEAR(clear_module_state->__pyx_n_s_MULT); - Py_CLEAR(clear_module_state->__pyx_n_s_NATR); - Py_CLEAR(clear_module_state->__pyx_n_s_NONE); - Py_CLEAR(clear_module_state->__pyx_n_s_Near); - Py_CLEAR(clear_module_state->__pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED); - Py_CLEAR(clear_module_state->__pyx_kp_s_Not_enough_price_arguments_expec); - Py_CLEAR(clear_module_state->__pyx_n_s_OBV); - Py_CLEAR(clear_module_state->__pyx_n_s_OrderedDict); - Py_CLEAR(clear_module_state->__pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF); - Py_CLEAR(clear_module_state->__pyx_kp_s_Out_of_Range_Start_Index_TA_OUT); - Py_CLEAR(clear_module_state->__pyx_kp_s_Output_Not_All_Initialized_TA_OU); - Py_CLEAR(clear_module_state->__pyx_kp_s_Output_can_be_negative); - Py_CLEAR(clear_module_state->__pyx_kp_s_Output_can_be_positive); - Py_CLEAR(clear_module_state->__pyx_kp_s_Output_can_be_zero); - Py_CLEAR(clear_module_state->__pyx_kp_s_Output_is_a_candlestick); - Py_CLEAR(clear_module_state->__pyx_kp_s_Output_is_over_volume); - Py_CLEAR(clear_module_state->__pyx_kp_s_Output_scale_same_as_input); - Py_CLEAR(clear_module_state->__pyx_kp_s_Outputs); - Py_CLEAR(clear_module_state->__pyx_n_s_PANDAS_DATAFRAME); - Py_CLEAR(clear_module_state->__pyx_n_s_PANDAS_SERIES); - Py_CLEAR(clear_module_state->__pyx_n_s_PLUS_DI); - Py_CLEAR(clear_module_state->__pyx_n_s_PLUS_DM); - Py_CLEAR(clear_module_state->__pyx_n_s_POLARS_DATAFRAME); - Py_CLEAR(clear_module_state->__pyx_n_s_POLARS_SERIES); - Py_CLEAR(clear_module_state->__pyx_n_s_PPO); - Py_CLEAR(clear_module_state->__pyx_kp_s_Parameters); - Py_CLEAR(clear_module_state->__pyx_kp_s_Pattern_Bool); - Py_CLEAR(clear_module_state->__pyx_n_s_ROC); - Py_CLEAR(clear_module_state->__pyx_n_s_ROCP); - Py_CLEAR(clear_module_state->__pyx_n_s_ROCR); - Py_CLEAR(clear_module_state->__pyx_n_s_ROCR100); - Py_CLEAR(clear_module_state->__pyx_n_s_RSI); - Py_CLEAR(clear_module_state->__pyx_n_s_RangeType); - Py_CLEAR(clear_module_state->__pyx_n_s_RealBody); - Py_CLEAR(clear_module_state->__pyx_n_s_SAR); - Py_CLEAR(clear_module_state->__pyx_n_s_SAREXT); - Py_CLEAR(clear_module_state->__pyx_n_s_SIN); - Py_CLEAR(clear_module_state->__pyx_n_s_SINH); - Py_CLEAR(clear_module_state->__pyx_n_s_SMA); - Py_CLEAR(clear_module_state->__pyx_n_s_SQRT); - Py_CLEAR(clear_module_state->__pyx_n_s_STDDEV); - Py_CLEAR(clear_module_state->__pyx_n_s_STOCH); - Py_CLEAR(clear_module_state->__pyx_n_s_STOCHF); - Py_CLEAR(clear_module_state->__pyx_n_s_STOCHRSI); - Py_CLEAR(clear_module_state->__pyx_n_s_SUB); - Py_CLEAR(clear_module_state->__pyx_n_s_SUM); - Py_CLEAR(clear_module_state->__pyx_n_s_Series); - Py_CLEAR(clear_module_state->__pyx_n_s_ShadowLong); - Py_CLEAR(clear_module_state->__pyx_n_s_ShadowShort); - Py_CLEAR(clear_module_state->__pyx_n_s_ShadowVeryLong); - Py_CLEAR(clear_module_state->__pyx_n_s_ShadowVeryShort); - Py_CLEAR(clear_module_state->__pyx_n_s_Shadows); - Py_CLEAR(clear_module_state->__pyx_kp_s_Simple_Moving_Average); - Py_CLEAR(clear_module_state->__pyx_kp_s_Strength_Pattern_200_100_Bearish); - Py_CLEAR(clear_module_state->__pyx_n_s_T3); - Py_CLEAR(clear_module_state->__pyx_n_s_TAN); - Py_CLEAR(clear_module_state->__pyx_n_s_TANH); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ACOS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_AD); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ADD); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ADOSC); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ADX); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ADXR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_APO); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_AROON); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_AROONOSC); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ASIN); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ATAN); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ATR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_AVGPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_BBANDS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_BETA); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_BOP); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CCI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDL2CROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDL3BLACKCROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDL3INSIDE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDL3LINESTRIKE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDL3OUTSIDE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDL3STARSINSOUTH); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDL3WHITESOLDIERS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLABANDONEDBABY); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLADVANCEBLOCK); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLBELTHOLD); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLBREAKAWAY); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLCLOSINGMARUBOZU); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLCONCEALBABYSWALL); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLCOUNTERATTACK); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLDARKCLOUDCOVER); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLDOJISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLDRAGONFLYDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLENGULFING); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLEVENINGDOJISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLEVENINGSTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLGAPSIDESIDEWHITE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLGRAVESTONEDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLHAMMER); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLHANGINGMAN); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLHARAMI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLHARAMICROSS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLHIGHWAVE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLHIKKAKE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLHIKKAKEMOD); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLHOMINGPIGEON); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLIDENTICAL3CROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLINNECK); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLINVERTEDHAMMER); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLKICKING); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLKICKINGBYLENGTH); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLLADDERBOTTOM); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLLONGLEGGEDDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLLONGLINE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLMARUBOZU); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLMATCHINGLOW); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLMATHOLD); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLMORNINGDOJISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLMORNINGSTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLONNECK); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLPIERCING); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLRICKSHAWMAN); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLRISEFALL3METHODS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLSEPARATINGLINES); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLSHOOTINGSTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLSHORTLINE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLSPINNINGTOP); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLSTALLEDPATTERN); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLSTICKSANDWICH); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLTAKURI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLTASUKIGAP); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLTHRUSTING); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLTRISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLUNIQUE3RIVER); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLUPSIDEGAP2CROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CDLXSIDEGAP3METHODS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CEIL); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CMO); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_CORREL); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_COS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_COSH); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_DEMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_DIV); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_DX); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_EMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_EXP); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_FLOOR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_FUNCTION_NAMES); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_FUNC_FLAGS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_FuncTableAlloc); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_FuncTableFree); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_GetFuncHandle); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_GetFuncInfo); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_GetInputParameterInfo); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_GetLookback); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_GetOptInputParameterInfo); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_GetOutputParameterInfo); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_GroupTableAlloc); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_GroupTableFree); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_HT_DCPERIOD); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_HT_DCPHASE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_HT_PHASOR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_HT_SINE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_HT_TRENDLINE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_HT_TRENDMODE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_INPUT_FLAGS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_Initialize); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_KAMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_LINEARREG); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_LINEARREG_ANGLE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_LINEARREG_INTERCEPT); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_LINEARREG_SLOPE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_LN); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_LOG10); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MA); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MACD); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MACDEXT); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MACDFIX); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MAMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MAVP); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MAX); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MAXINDEX); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MEDPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MFI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MIDPOINT); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MIDPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MIN); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MININDEX); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MINMAX); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MINMAXINDEX); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MINUS_DI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MINUS_DM); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MOM); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_MULT); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_NATR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_OBV); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_OUTPUT_FLAGS); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_PLUS_DI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_PLUS_DM); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_PPO); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ParamHolderAlloc); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ParamHolderFree); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ROC); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ROCP); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ROCR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ROCR100); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_RSI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_RestoreCandleDefaultSettings); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SAR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SAREXT); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SIN); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SINH); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SQRT); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_STDDEV); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_STOCH); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_STOCHF); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_STOCHRSI); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SUB); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SUM); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SetCandleSettings); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SetCompatibility); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SetOptInputParamInteger); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SetOptInputParamReal); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_SetUnstablePeriod); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_Shutdown); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_T3); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_TAN); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_TANH); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_TEMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_TRANGE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_TRIMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_TRIX); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_TSF); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_TYPPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_ULTOSC); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_VAR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_WCLPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_WILLR); - Py_CLEAR(clear_module_state->__pyx_n_s_TA_WMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TEMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TRANGE); - Py_CLEAR(clear_module_state->__pyx_n_s_TRIMA); - Py_CLEAR(clear_module_state->__pyx_n_s_TRIX); - Py_CLEAR(clear_module_state->__pyx_n_s_TSF); - Py_CLEAR(clear_module_state->__pyx_n_s_TYPPRICE); - Py_CLEAR(clear_module_state->__pyx_kp_s_This_is_a_pythonic_wrapper_arou); - Py_CLEAR(clear_module_state->__pyx_kp_s_Too_many_price_arguments_expecte); - Py_CLEAR(clear_module_state->__pyx_kp_s_Triangular_Moving_Average); - Py_CLEAR(clear_module_state->__pyx_kp_s_Triple_Exponential_Moving_Averag); - Py_CLEAR(clear_module_state->__pyx_kp_s_Triple_Generalized_Double_Expone); - Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); - Py_CLEAR(clear_module_state->__pyx_n_s_ULTOSC); - Py_CLEAR(clear_module_state->__pyx_kp_s_Unknown_Error); - Py_CLEAR(clear_module_state->__pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR); - Py_CLEAR(clear_module_state->__pyx_n_s_VAR); - Py_CLEAR(clear_module_state->__pyx_kp_s_Values_represent_a_lower_limit); - Py_CLEAR(clear_module_state->__pyx_kp_s_Values_represent_an_upper_limit); - Py_CLEAR(clear_module_state->__pyx_n_s_WCLPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_WILLR); - Py_CLEAR(clear_module_state->__pyx_n_s_WMA); - Py_CLEAR(clear_module_state->__pyx_kp_s_Weighted_Moving_Average); - Py_CLEAR(clear_module_state->__pyx_kp_s__10); - Py_CLEAR(clear_module_state->__pyx_kp_s__11); - Py_CLEAR(clear_module_state->__pyx_kp_s__12); - Py_CLEAR(clear_module_state->__pyx_n_s__240); - Py_CLEAR(clear_module_state->__pyx_kp_u__43); - Py_CLEAR(clear_module_state->__pyx_n_s__503); - Py_CLEAR(clear_module_state->__pyx_kp_s__6); - Py_CLEAR(clear_module_state->__pyx_kp_s__7); - Py_CLEAR(clear_module_state->__pyx_kp_s__9); - Py_CLEAR(clear_module_state->__pyx_n_s_acceleration); - Py_CLEAR(clear_module_state->__pyx_n_s_accelerationinitlong); - Py_CLEAR(clear_module_state->__pyx_n_s_accelerationinitshort); - Py_CLEAR(clear_module_state->__pyx_n_s_accelerationlong); - Py_CLEAR(clear_module_state->__pyx_n_s_accelerationmaxlong); - Py_CLEAR(clear_module_state->__pyx_n_s_accelerationmaxshort); - Py_CLEAR(clear_module_state->__pyx_n_s_accelerationshort); - Py_CLEAR(clear_module_state->__pyx_n_s_all); - Py_CLEAR(clear_module_state->__pyx_kp_s_any_ndarray); - Py_CLEAR(clear_module_state->__pyx_n_s_append); - Py_CLEAR(clear_module_state->__pyx_n_s_arg); - Py_CLEAR(clear_module_state->__pyx_n_s_args); - Py_CLEAR(clear_module_state->__pyx_n_s_ascii); - Py_CLEAR(clear_module_state->__pyx_n_s_astype); - Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); - Py_CLEAR(clear_module_state->__pyx_n_s_avgperiod); - Py_CLEAR(clear_module_state->__pyx_n_s_b); - Py_CLEAR(clear_module_state->__pyx_n_s_begidx); - Py_CLEAR(clear_module_state->__pyx_n_s_bytes2str); - Py_CLEAR(clear_module_state->__pyx_n_s_call); - Py_CLEAR(clear_module_state->__pyx_n_s_call_function); - Py_CLEAR(clear_module_state->__pyx_n_s_check_opt_input_value); - Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem); - Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); - Py_CLEAR(clear_module_state->__pyx_n_s_clone); - Py_CLEAR(clear_module_state->__pyx_n_s_close); - Py_CLEAR(clear_module_state->__pyx_n_s_close_data); - Py_CLEAR(clear_module_state->__pyx_n_s_collections); - Py_CLEAR(clear_module_state->__pyx_n_s_column_stack); - Py_CLEAR(clear_module_state->__pyx_n_s_columns); - Py_CLEAR(clear_module_state->__pyx_n_s_copy); - Py_CLEAR(clear_module_state->__pyx_n_s_decode); - Py_CLEAR(clear_module_state->__pyx_n_s_default_value); - Py_CLEAR(clear_module_state->__pyx_n_s_defaults); - Py_CLEAR(clear_module_state->__pyx_n_s_dict); - Py_CLEAR(clear_module_state->__pyx_n_s_display_name); - Py_CLEAR(clear_module_state->__pyx_kp_s_display_name_s_group_s); - Py_CLEAR(clear_module_state->__pyx_n_s_doc); - Py_CLEAR(clear_module_state->__pyx_n_s_docs); - Py_CLEAR(clear_module_state->__pyx_n_s_documentation); - Py_CLEAR(clear_module_state->__pyx_n_s_empty); - Py_CLEAR(clear_module_state->__pyx_n_s_endidx); - Py_CLEAR(clear_module_state->__pyx_n_s_enumerate); - Py_CLEAR(clear_module_state->__pyx_n_s_factor); - Py_CLEAR(clear_module_state->__pyx_n_s_fastd_matype); - Py_CLEAR(clear_module_state->__pyx_n_s_fastd_period); - Py_CLEAR(clear_module_state->__pyx_n_s_fastk_period); - Py_CLEAR(clear_module_state->__pyx_n_s_fastlimit); - Py_CLEAR(clear_module_state->__pyx_n_s_fastmatype); - Py_CLEAR(clear_module_state->__pyx_n_s_fastperiod); - Py_CLEAR(clear_module_state->__pyx_n_s_flag); - Py_CLEAR(clear_module_state->__pyx_n_s_flags); - Py_CLEAR(clear_module_state->__pyx_n_s_flags_lookup_dict); - Py_CLEAR(clear_module_state->__pyx_n_s_func_args); - Py_CLEAR(clear_module_state->__pyx_n_s_func_info); - Py_CLEAR(clear_module_state->__pyx_n_s_func_line); - Py_CLEAR(clear_module_state->__pyx_n_s_func_object); - Py_CLEAR(clear_module_state->__pyx_n_s_function_flags); - Py_CLEAR(clear_module_state->__pyx_n_s_function_name); - Py_CLEAR(clear_module_state->__pyx_n_s_functions); - Py_CLEAR(clear_module_state->__pyx_n_s_get_defaults_and_docs); - Py_CLEAR(clear_module_state->__pyx_n_s_get_flags); - Py_CLEAR(clear_module_state->__pyx_n_s_get_input_arrays); - Py_CLEAR(clear_module_state->__pyx_n_s_get_input_names); - Py_CLEAR(clear_module_state->__pyx_n_s_get_opt_input_value); - Py_CLEAR(clear_module_state->__pyx_n_s_get_parameters); - Py_CLEAR(clear_module_state->__pyx_n_s_getitem); - Py_CLEAR(clear_module_state->__pyx_n_s_group); - Py_CLEAR(clear_module_state->__pyx_n_s_groups); - Py_CLEAR(clear_module_state->__pyx_n_s_help); - Py_CLEAR(clear_module_state->__pyx_n_s_high); - Py_CLEAR(clear_module_state->__pyx_n_s_high_data); - Py_CLEAR(clear_module_state->__pyx_n_s_holder); - Py_CLEAR(clear_module_state->__pyx_n_s_i); - Py_CLEAR(clear_module_state->__pyx_n_s_id); - Py_CLEAR(clear_module_state->__pyx_n_s_idx); - Py_CLEAR(clear_module_state->__pyx_n_s_import); - Py_CLEAR(clear_module_state->__pyx_n_s_in); - Py_CLEAR(clear_module_state->__pyx_n_s_index); - Py_CLEAR(clear_module_state->__pyx_n_s_info); - Py_CLEAR(clear_module_state->__pyx_n_s_init); - Py_CLEAR(clear_module_state->__pyx_n_s_init_subclass); - Py_CLEAR(clear_module_state->__pyx_n_s_initializing); - Py_CLEAR(clear_module_state->__pyx_kp_s_input_array_has_wrong_dimensions); - Py_CLEAR(clear_module_state->__pyx_kp_s_input_array_lengths_are_differen); - Py_CLEAR(clear_module_state->__pyx_kp_s_input_array_type_is_not_double); - Py_CLEAR(clear_module_state->__pyx_n_s_input_arrays); - Py_CLEAR(clear_module_state->__pyx_kp_s_input_arrays_2); - Py_CLEAR(clear_module_state->__pyx_kp_s_input_arrays_parameter_missing_r); - Py_CLEAR(clear_module_state->__pyx_n_s_input_name); - Py_CLEAR(clear_module_state->__pyx_n_s_input_names); - Py_CLEAR(clear_module_state->__pyx_n_s_input_price_series_names); - Py_CLEAR(clear_module_state->__pyx_n_s_input_price_series_names_2); - Py_CLEAR(clear_module_state->__pyx_n_s_integer); - Py_CLEAR(clear_module_state->__pyx_kp_s_integer_values_are_100_0_or_100); - Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); - Py_CLEAR(clear_module_state->__pyx_n_s_is_empty); - Py_CLEAR(clear_module_state->__pyx_n_s_items); - Py_CLEAR(clear_module_state->__pyx_n_s_join); - Py_CLEAR(clear_module_state->__pyx_n_s_key); - Py_CLEAR(clear_module_state->__pyx_n_s_keys); - Py_CLEAR(clear_module_state->__pyx_n_s_kwargs); - Py_CLEAR(clear_module_state->__pyx_n_s_length); - Py_CLEAR(clear_module_state->__pyx_n_s_local); - Py_CLEAR(clear_module_state->__pyx_n_s_local_2); - Py_CLEAR(clear_module_state->__pyx_n_s_log); - Py_CLEAR(clear_module_state->__pyx_n_s_lookback); - Py_CLEAR(clear_module_state->__pyx_n_s_lookup); - Py_CLEAR(clear_module_state->__pyx_n_s_low); - Py_CLEAR(clear_module_state->__pyx_n_s_low_data); - Py_CLEAR(clear_module_state->__pyx_n_s_lower); - Py_CLEAR(clear_module_state->__pyx_n_s_main); - Py_CLEAR(clear_module_state->__pyx_n_s_math); - Py_CLEAR(clear_module_state->__pyx_n_s_matype); - Py_CLEAR(clear_module_state->__pyx_n_s_max); - Py_CLEAR(clear_module_state->__pyx_n_s_max_int); - Py_CLEAR(clear_module_state->__pyx_n_s_maximum); - Py_CLEAR(clear_module_state->__pyx_n_s_maxperiod); - Py_CLEAR(clear_module_state->__pyx_n_s_metaclass); - Py_CLEAR(clear_module_state->__pyx_n_s_min); - Py_CLEAR(clear_module_state->__pyx_n_s_min_int); - Py_CLEAR(clear_module_state->__pyx_n_s_minperiod); - Py_CLEAR(clear_module_state->__pyx_n_s_missing); - Py_CLEAR(clear_module_state->__pyx_n_s_missing_keys); - Py_CLEAR(clear_module_state->__pyx_n_s_module); - Py_CLEAR(clear_module_state->__pyx_n_s_mro_entries); - Py_CLEAR(clear_module_state->__pyx_n_s_msg); - Py_CLEAR(clear_module_state->__pyx_n_s_n); - Py_CLEAR(clear_module_state->__pyx_n_s_name); - Py_CLEAR(clear_module_state->__pyx_n_s_name_2); - Py_CLEAR(clear_module_state->__pyx_n_s_nan); - Py_CLEAR(clear_module_state->__pyx_n_s_nbdev); - Py_CLEAR(clear_module_state->__pyx_n_s_nbdevdn); - Py_CLEAR(clear_module_state->__pyx_n_s_nbdevup); - Py_CLEAR(clear_module_state->__pyx_n_s_no_existing_input_arrays); - Py_CLEAR(clear_module_state->__pyx_n_s_num_inputs); - Py_CLEAR(clear_module_state->__pyx_n_s_num_opt_inputs); - Py_CLEAR(clear_module_state->__pyx_n_s_num_outputs); - Py_CLEAR(clear_module_state->__pyx_n_s_numpy); - Py_CLEAR(clear_module_state->__pyx_kp_s_numpy_core_multiarray_failed_to); - Py_CLEAR(clear_module_state->__pyx_kp_s_numpy_core_umath_failed_to_impor); - Py_CLEAR(clear_module_state->__pyx_n_s_object); - Py_CLEAR(clear_module_state->__pyx_n_s_offsetonreverse); - Py_CLEAR(clear_module_state->__pyx_n_s_open); - Py_CLEAR(clear_module_state->__pyx_n_s_openInterest); - Py_CLEAR(clear_module_state->__pyx_n_s_open_data); - Py_CLEAR(clear_module_state->__pyx_n_s_optIn); - Py_CLEAR(clear_module_state->__pyx_n_s_opt_input); - Py_CLEAR(clear_module_state->__pyx_n_s_opt_input_values); - Py_CLEAR(clear_module_state->__pyx_n_s_opt_inputs); - Py_CLEAR(clear_module_state->__pyx_n_s_ordereddict); - Py_CLEAR(clear_module_state->__pyx_n_s_out); - Py_CLEAR(clear_module_state->__pyx_n_s_outaroondown); - Py_CLEAR(clear_module_state->__pyx_n_s_outaroonup); - Py_CLEAR(clear_module_state->__pyx_n_s_outbegidx); - Py_CLEAR(clear_module_state->__pyx_n_s_outfama); - Py_CLEAR(clear_module_state->__pyx_n_s_outfastd); - Py_CLEAR(clear_module_state->__pyx_n_s_outfastk); - Py_CLEAR(clear_module_state->__pyx_n_s_outinphase); - Py_CLEAR(clear_module_state->__pyx_n_s_outinteger); - Py_CLEAR(clear_module_state->__pyx_n_s_outinteger_data); - Py_CLEAR(clear_module_state->__pyx_n_s_outleadsine); - Py_CLEAR(clear_module_state->__pyx_n_s_outmacd); - Py_CLEAR(clear_module_state->__pyx_n_s_outmacdhist); - Py_CLEAR(clear_module_state->__pyx_n_s_outmacdsignal); - Py_CLEAR(clear_module_state->__pyx_n_s_outmama); - Py_CLEAR(clear_module_state->__pyx_n_s_outmax); - Py_CLEAR(clear_module_state->__pyx_n_s_outmaxidx); - Py_CLEAR(clear_module_state->__pyx_n_s_outmaxidx_data); - Py_CLEAR(clear_module_state->__pyx_n_s_outmin); - Py_CLEAR(clear_module_state->__pyx_n_s_outminidx); - Py_CLEAR(clear_module_state->__pyx_n_s_outminidx_data); - Py_CLEAR(clear_module_state->__pyx_n_s_outnbelement); - Py_CLEAR(clear_module_state->__pyx_n_s_output); - Py_CLEAR(clear_module_state->__pyx_n_s_output_flags); - Py_CLEAR(clear_module_state->__pyx_n_s_output_name); - Py_CLEAR(clear_module_state->__pyx_n_s_output_names); - Py_CLEAR(clear_module_state->__pyx_n_s_outputs); - Py_CLEAR(clear_module_state->__pyx_n_s_outputs_valid); - Py_CLEAR(clear_module_state->__pyx_n_s_outquadrature); - Py_CLEAR(clear_module_state->__pyx_n_s_outreal); - Py_CLEAR(clear_module_state->__pyx_n_s_outreallowerband); - Py_CLEAR(clear_module_state->__pyx_n_s_outrealmiddleband); - Py_CLEAR(clear_module_state->__pyx_n_s_outrealupperband); - Py_CLEAR(clear_module_state->__pyx_n_s_outsine); - Py_CLEAR(clear_module_state->__pyx_n_s_outslowd); - Py_CLEAR(clear_module_state->__pyx_n_s_outslowk); - Py_CLEAR(clear_module_state->__pyx_n_s_pandas); - Py_CLEAR(clear_module_state->__pyx_n_s_param); - Py_CLEAR(clear_module_state->__pyx_n_s_param_name); - Py_CLEAR(clear_module_state->__pyx_n_s_parameters); - Py_CLEAR(clear_module_state->__pyx_n_s_params); - Py_CLEAR(clear_module_state->__pyx_n_s_penetration); - Py_CLEAR(clear_module_state->__pyx_n_s_period); - Py_CLEAR(clear_module_state->__pyx_n_s_periods); - Py_CLEAR(clear_module_state->__pyx_n_s_periods_data); - Py_CLEAR(clear_module_state->__pyx_n_s_polars); - Py_CLEAR(clear_module_state->__pyx_n_s_pop); - Py_CLEAR(clear_module_state->__pyx_n_s_prepare); - Py_CLEAR(clear_module_state->__pyx_n_s_price); - Py_CLEAR(clear_module_state->__pyx_n_s_price0); - Py_CLEAR(clear_module_state->__pyx_n_s_price1); - Py_CLEAR(clear_module_state->__pyx_n_s_price_series); - Py_CLEAR(clear_module_state->__pyx_n_s_price_series_name_values); - Py_CLEAR(clear_module_state->__pyx_n_s_prices); - Py_CLEAR(clear_module_state->__pyx_n_s_property); - Py_CLEAR(clear_module_state->__pyx_n_s_qualname); - Py_CLEAR(clear_module_state->__pyx_n_s_range); - Py_CLEAR(clear_module_state->__pyx_n_s_rangetype); - Py_CLEAR(clear_module_state->__pyx_n_s_real); - Py_CLEAR(clear_module_state->__pyx_n_s_real0); - Py_CLEAR(clear_module_state->__pyx_n_s_real0_data); - Py_CLEAR(clear_module_state->__pyx_n_s_real1); - Py_CLEAR(clear_module_state->__pyx_n_s_real1_data); - Py_CLEAR(clear_module_state->__pyx_n_s_real_data); - Py_CLEAR(clear_module_state->__pyx_n_s_replace); - Py_CLEAR(clear_module_state->__pyx_n_s_repr); - Py_CLEAR(clear_module_state->__pyx_n_s_results); - Py_CLEAR(clear_module_state->__pyx_n_s_ret); - Py_CLEAR(clear_module_state->__pyx_n_s_retCode); - Py_CLEAR(clear_module_state->__pyx_n_s_ret_code); - Py_CLEAR(clear_module_state->__pyx_n_s_run); - Py_CLEAR(clear_module_state->__pyx_n_s_s); - Py_CLEAR(clear_module_state->__pyx_kp_s_s_2); - Py_CLEAR(clear_module_state->__pyx_kp_s_s_3); - Py_CLEAR(clear_module_state->__pyx_kp_s_s_4); - Py_CLEAR(clear_module_state->__pyx_kp_s_s_function_failed_with_error_co); - Py_CLEAR(clear_module_state->__pyx_kp_s_s_s); - Py_CLEAR(clear_module_state->__pyx_kp_s_s_s_2); - Py_CLEAR(clear_module_state->__pyx_n_s_schema); - Py_CLEAR(clear_module_state->__pyx_n_s_self); - Py_CLEAR(clear_module_state->__pyx_n_s_series); - Py_CLEAR(clear_module_state->__pyx_n_s_set_function_args); - Py_CLEAR(clear_module_state->__pyx_n_s_set_input_arrays); - Py_CLEAR(clear_module_state->__pyx_n_s_set_input_names); - Py_CLEAR(clear_module_state->__pyx_n_s_set_name); - Py_CLEAR(clear_module_state->__pyx_n_s_set_parameters); - Py_CLEAR(clear_module_state->__pyx_n_s_settingtype); - Py_CLEAR(clear_module_state->__pyx_n_s_signalmatype); - Py_CLEAR(clear_module_state->__pyx_n_s_signalperiod); - Py_CLEAR(clear_module_state->__pyx_n_s_skip_first); - Py_CLEAR(clear_module_state->__pyx_n_s_slowd_matype); - Py_CLEAR(clear_module_state->__pyx_n_s_slowd_period); - Py_CLEAR(clear_module_state->__pyx_n_s_slowk_matype); - Py_CLEAR(clear_module_state->__pyx_n_s_slowk_period); - Py_CLEAR(clear_module_state->__pyx_n_s_slowlimit); - Py_CLEAR(clear_module_state->__pyx_n_s_slowmatype); - Py_CLEAR(clear_module_state->__pyx_n_s_slowperiod); - Py_CLEAR(clear_module_state->__pyx_n_s_spec); - Py_CLEAR(clear_module_state->__pyx_n_s_startvalue); - Py_CLEAR(clear_module_state->__pyx_n_s_str); - Py_CLEAR(clear_module_state->__pyx_n_s_str2bytes); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ACOS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_AD); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ADD); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ADOSC); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ADX); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ADXR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_APO); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_AROON); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_AROONOSC); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ASIN); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ATAN); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ATR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_AVGPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_BBANDS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_BETA); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_BOP); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CCI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDL2CROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDL3BLACKCROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDL3INSIDE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDL3LINESTRIKE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDL3OUTSIDE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDL3STARSINSOUTH); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDL3WHITESOLDIERS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLABANDONEDBABY); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLADVANCEBLOCK); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLBELTHOLD); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLBREAKAWAY); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLCLOSINGMARUBOZU); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLCONCEALBABYSWALL); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLCOUNTERATTACK); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLDARKCLOUDCOVER); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLDOJISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLDRAGONFLYDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLENGULFING); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLEVENINGDOJISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLEVENINGSTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLGAPSIDESIDEWHITE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLGRAVESTONEDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLHAMMER); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLHANGINGMAN); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLHARAMI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLHARAMICROSS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLHIGHWAVE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLHIKKAKE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLHIKKAKEMOD); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLHOMINGPIGEON); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLIDENTICAL3CROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLINNECK); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLINVERTEDHAMMER); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLKICKING); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLKICKINGBYLENGTH); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLLADDERBOTTOM); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLLONGLEGGEDDOJI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLLONGLINE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLMARUBOZU); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLMATCHINGLOW); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLMATHOLD); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLMORNINGDOJISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLMORNINGSTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLONNECK); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLPIERCING); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLRICKSHAWMAN); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLRISEFALL3METHODS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLSEPARATINGLINES); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLSHOOTINGSTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLSHORTLINE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLSPINNINGTOP); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLSTALLEDPATTERN); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLSTICKSANDWICH); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLTAKURI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLTASUKIGAP); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLTHRUSTING); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLTRISTAR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLUNIQUE3RIVER); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLUPSIDEGAP2CROWS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CDLXSIDEGAP3METHODS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CEIL); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CMO); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_CORREL); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_COS); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_COSH); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_DEMA); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_DIV); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_DX); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_EMA); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_EXP); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_FLOOR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_HT_DCPERIOD); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_HT_DCPHASE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_HT_PHASOR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_HT_SINE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_HT_TRENDLINE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_HT_TRENDMODE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_KAMA); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_LINEARREG); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_LINEARREG_ANGLE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_LINEARREG_INTERCEPT); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_LINEARREG_SLOPE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_LN); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_LOG10); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MA); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MACD); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MACDEXT); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MACDFIX); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MAMA); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MAVP); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MAX); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MAXINDEX); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MEDPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MFI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MIDPOINT); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MIDPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MIN); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MININDEX); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MINMAX); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MINMAXINDEX); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MINUS_DI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MINUS_DM); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MOM); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_MULT); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_NATR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_OBV); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_PLUS_DI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_PLUS_DM); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_PPO); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ROC); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ROCP); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ROCR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ROCR100); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_RSI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_SAR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_SAREXT); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_SIN); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_SINH); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_SMA); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_SQRT); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_STDDEV); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_STOCH); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_STOCHF); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_STOCHRSI); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_SUB); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_SUM); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_T3); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_TAN); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_TANH); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_TEMA); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_TRANGE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_TRIMA); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_TRIX); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_TSF); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_TYPPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_ULTOSC); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_VAR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_WCLPRICE); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_WILLR); - Py_CLEAR(clear_module_state->__pyx_n_s_stream_WMA); - Py_CLEAR(clear_module_state->__pyx_kp_s_stream__s); - Py_CLEAR(clear_module_state->__pyx_n_s_super); - Py_CLEAR(clear_module_state->__pyx_n_s_sys); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_check_success); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_func_unst_ids); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_getFuncInfo); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_getFuncTable); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_getGroupTable); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_getInputParameterInfo); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_getOptInputParameterInfo); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_getOutputParameterInfo); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_get_compatibility); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_get_unstable_period); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_initialize); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_restore_candle_default_setti); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_set_candle_settings); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_set_compatibility); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_set_unstable_period); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_shutdown); - Py_CLEAR(clear_module_state->__pyx_n_s_ta_version); - Py_CLEAR(clear_module_state->__pyx_n_s_table); - Py_CLEAR(clear_module_state->__pyx_kp_s_talib__abstract_pxi); - Py_CLEAR(clear_module_state->__pyx_kp_s_talib__common_pxi); - Py_CLEAR(clear_module_state->__pyx_kp_s_talib__func_pxi); - Py_CLEAR(clear_module_state->__pyx_kp_s_talib__stream_pxi); - Py_CLEAR(clear_module_state->__pyx_n_s_talib__ta_lib); - Py_CLEAR(clear_module_state->__pyx_n_s_test); - Py_CLEAR(clear_module_state->__pyx_n_s_threading); - Py_CLEAR(clear_module_state->__pyx_n_s_timeStamp); - Py_CLEAR(clear_module_state->__pyx_n_s_timeperiod); - Py_CLEAR(clear_module_state->__pyx_n_s_timeperiod1); - Py_CLEAR(clear_module_state->__pyx_n_s_timeperiod2); - Py_CLEAR(clear_module_state->__pyx_n_s_timeperiod3); - Py_CLEAR(clear_module_state->__pyx_n_s_to_numpy); - Py_CLEAR(clear_module_state->__pyx_n_s_type); - Py_CLEAR(clear_module_state->__pyx_n_s_type_2); - Py_CLEAR(clear_module_state->__pyx_n_s_unicode); - Py_CLEAR(clear_module_state->__pyx_n_s_update); - Py_CLEAR(clear_module_state->__pyx_n_s_update_info); - Py_CLEAR(clear_module_state->__pyx_n_s_upper); - Py_CLEAR(clear_module_state->__pyx_n_s_value); - Py_CLEAR(clear_module_state->__pyx_n_s_value_range); - Py_CLEAR(clear_module_state->__pyx_n_s_values); - Py_CLEAR(clear_module_state->__pyx_n_s_version); - Py_CLEAR(clear_module_state->__pyx_n_s_vfactor); - Py_CLEAR(clear_module_state->__pyx_n_s_volume); - Py_CLEAR(clear_module_state->__pyx_n_s_volume_data); - Py_CLEAR(clear_module_state->__pyx_n_s_xrange); - 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); - Py_CLEAR(clear_module_state->__pyx_tuple_); - Py_CLEAR(clear_module_state->__pyx_tuple__2); - Py_CLEAR(clear_module_state->__pyx_tuple__3); - Py_CLEAR(clear_module_state->__pyx_tuple__4); - Py_CLEAR(clear_module_state->__pyx_tuple__5); - Py_CLEAR(clear_module_state->__pyx_tuple__8); - Py_CLEAR(clear_module_state->__pyx_tuple__13); - Py_CLEAR(clear_module_state->__pyx_tuple__15); - Py_CLEAR(clear_module_state->__pyx_tuple__18); - Py_CLEAR(clear_module_state->__pyx_tuple__19); - Py_CLEAR(clear_module_state->__pyx_tuple__20); - Py_CLEAR(clear_module_state->__pyx_tuple__21); - Py_CLEAR(clear_module_state->__pyx_tuple__23); - Py_CLEAR(clear_module_state->__pyx_tuple__25); - Py_CLEAR(clear_module_state->__pyx_tuple__27); - Py_CLEAR(clear_module_state->__pyx_tuple__29); - Py_CLEAR(clear_module_state->__pyx_tuple__31); - Py_CLEAR(clear_module_state->__pyx_tuple__33); - Py_CLEAR(clear_module_state->__pyx_tuple__34); - Py_CLEAR(clear_module_state->__pyx_tuple__35); - Py_CLEAR(clear_module_state->__pyx_tuple__36); - Py_CLEAR(clear_module_state->__pyx_tuple__37); - Py_CLEAR(clear_module_state->__pyx_tuple__38); - Py_CLEAR(clear_module_state->__pyx_tuple__39); - Py_CLEAR(clear_module_state->__pyx_tuple__41); - Py_CLEAR(clear_module_state->__pyx_tuple__44); - Py_CLEAR(clear_module_state->__pyx_tuple__46); - Py_CLEAR(clear_module_state->__pyx_tuple__48); - Py_CLEAR(clear_module_state->__pyx_tuple__50); - Py_CLEAR(clear_module_state->__pyx_tuple__52); - Py_CLEAR(clear_module_state->__pyx_tuple__55); - Py_CLEAR(clear_module_state->__pyx_tuple__57); - Py_CLEAR(clear_module_state->__pyx_tuple__59); - Py_CLEAR(clear_module_state->__pyx_tuple__64); - Py_CLEAR(clear_module_state->__pyx_tuple__66); - Py_CLEAR(clear_module_state->__pyx_tuple__68); - Py_CLEAR(clear_module_state->__pyx_tuple__72); - Py_CLEAR(clear_module_state->__pyx_tuple__80); - Py_CLEAR(clear_module_state->__pyx_tuple__136); - Py_CLEAR(clear_module_state->__pyx_tuple__149); - Py_CLEAR(clear_module_state->__pyx_tuple__151); - Py_CLEAR(clear_module_state->__pyx_tuple__154); - Py_CLEAR(clear_module_state->__pyx_tuple__163); - Py_CLEAR(clear_module_state->__pyx_tuple__165); - Py_CLEAR(clear_module_state->__pyx_tuple__167); - Py_CLEAR(clear_module_state->__pyx_tuple__169); - Py_CLEAR(clear_module_state->__pyx_tuple__171); - Py_CLEAR(clear_module_state->__pyx_tuple__173); - Py_CLEAR(clear_module_state->__pyx_tuple__176); - Py_CLEAR(clear_module_state->__pyx_tuple__178); - Py_CLEAR(clear_module_state->__pyx_tuple__180); - Py_CLEAR(clear_module_state->__pyx_tuple__186); - Py_CLEAR(clear_module_state->__pyx_tuple__188); - Py_CLEAR(clear_module_state->__pyx_tuple__195); - Py_CLEAR(clear_module_state->__pyx_tuple__205); - Py_CLEAR(clear_module_state->__pyx_tuple__207); - Py_CLEAR(clear_module_state->__pyx_tuple__213); - Py_CLEAR(clear_module_state->__pyx_tuple__215); - Py_CLEAR(clear_module_state->__pyx_tuple__217); - Py_CLEAR(clear_module_state->__pyx_tuple__219); - Py_CLEAR(clear_module_state->__pyx_tuple__223); - Py_CLEAR(clear_module_state->__pyx_tuple__228); - Py_CLEAR(clear_module_state->__pyx_tuple__234); - Py_CLEAR(clear_module_state->__pyx_tuple__241); - Py_CLEAR(clear_module_state->__pyx_tuple__243); - Py_CLEAR(clear_module_state->__pyx_tuple__247); - Py_CLEAR(clear_module_state->__pyx_tuple__248); - Py_CLEAR(clear_module_state->__pyx_tuple__249); - Py_CLEAR(clear_module_state->__pyx_tuple__251); - Py_CLEAR(clear_module_state->__pyx_tuple__256); - Py_CLEAR(clear_module_state->__pyx_tuple__258); - Py_CLEAR(clear_module_state->__pyx_tuple__260); - Py_CLEAR(clear_module_state->__pyx_tuple__262); - Py_CLEAR(clear_module_state->__pyx_tuple__264); - Py_CLEAR(clear_module_state->__pyx_tuple__266); - Py_CLEAR(clear_module_state->__pyx_tuple__268); - Py_CLEAR(clear_module_state->__pyx_tuple__269); - Py_CLEAR(clear_module_state->__pyx_tuple__271); - Py_CLEAR(clear_module_state->__pyx_tuple__273); - Py_CLEAR(clear_module_state->__pyx_tuple__275); - Py_CLEAR(clear_module_state->__pyx_tuple__277); - Py_CLEAR(clear_module_state->__pyx_tuple__279); - Py_CLEAR(clear_module_state->__pyx_tuple__281); - Py_CLEAR(clear_module_state->__pyx_tuple__283); - Py_CLEAR(clear_module_state->__pyx_tuple__285); - Py_CLEAR(clear_module_state->__pyx_tuple__287); - Py_CLEAR(clear_module_state->__pyx_tuple__292); - Py_CLEAR(clear_module_state->__pyx_tuple__294); - Py_CLEAR(clear_module_state->__pyx_tuple__296); - Py_CLEAR(clear_module_state->__pyx_tuple__298); - Py_CLEAR(clear_module_state->__pyx_tuple__300); - Py_CLEAR(clear_module_state->__pyx_tuple__302); - Py_CLEAR(clear_module_state->__pyx_tuple__305); - Py_CLEAR(clear_module_state->__pyx_tuple__307); - Py_CLEAR(clear_module_state->__pyx_tuple__309); - Py_CLEAR(clear_module_state->__pyx_tuple__311); - Py_CLEAR(clear_module_state->__pyx_tuple__313); - Py_CLEAR(clear_module_state->__pyx_tuple__315); - Py_CLEAR(clear_module_state->__pyx_tuple__318); - Py_CLEAR(clear_module_state->__pyx_tuple__320); - Py_CLEAR(clear_module_state->__pyx_tuple__322); - Py_CLEAR(clear_module_state->__pyx_tuple__327); - Py_CLEAR(clear_module_state->__pyx_tuple__329); - Py_CLEAR(clear_module_state->__pyx_tuple__331); - Py_CLEAR(clear_module_state->__pyx_tuple__335); - Py_CLEAR(clear_module_state->__pyx_tuple__343); - Py_CLEAR(clear_module_state->__pyx_tuple__399); - Py_CLEAR(clear_module_state->__pyx_tuple__412); - Py_CLEAR(clear_module_state->__pyx_tuple__414); - Py_CLEAR(clear_module_state->__pyx_tuple__417); - Py_CLEAR(clear_module_state->__pyx_tuple__426); - Py_CLEAR(clear_module_state->__pyx_tuple__428); - Py_CLEAR(clear_module_state->__pyx_tuple__430); - Py_CLEAR(clear_module_state->__pyx_tuple__432); - Py_CLEAR(clear_module_state->__pyx_tuple__434); - Py_CLEAR(clear_module_state->__pyx_tuple__436); - Py_CLEAR(clear_module_state->__pyx_tuple__439); - Py_CLEAR(clear_module_state->__pyx_tuple__441); - Py_CLEAR(clear_module_state->__pyx_tuple__443); - Py_CLEAR(clear_module_state->__pyx_tuple__449); - Py_CLEAR(clear_module_state->__pyx_tuple__451); - Py_CLEAR(clear_module_state->__pyx_tuple__458); - Py_CLEAR(clear_module_state->__pyx_tuple__468); - Py_CLEAR(clear_module_state->__pyx_tuple__470); - Py_CLEAR(clear_module_state->__pyx_tuple__476); - Py_CLEAR(clear_module_state->__pyx_tuple__478); - Py_CLEAR(clear_module_state->__pyx_tuple__480); - Py_CLEAR(clear_module_state->__pyx_tuple__482); - Py_CLEAR(clear_module_state->__pyx_tuple__486); - Py_CLEAR(clear_module_state->__pyx_tuple__491); - Py_CLEAR(clear_module_state->__pyx_tuple__497); - Py_CLEAR(clear_module_state->__pyx_codeobj__14); - Py_CLEAR(clear_module_state->__pyx_codeobj__16); - Py_CLEAR(clear_module_state->__pyx_codeobj__17); - Py_CLEAR(clear_module_state->__pyx_codeobj__22); - Py_CLEAR(clear_module_state->__pyx_codeobj__24); - Py_CLEAR(clear_module_state->__pyx_codeobj__26); - Py_CLEAR(clear_module_state->__pyx_codeobj__28); - Py_CLEAR(clear_module_state->__pyx_codeobj__30); - Py_CLEAR(clear_module_state->__pyx_codeobj__32); - Py_CLEAR(clear_module_state->__pyx_codeobj__40); - Py_CLEAR(clear_module_state->__pyx_codeobj__42); - Py_CLEAR(clear_module_state->__pyx_codeobj__45); - Py_CLEAR(clear_module_state->__pyx_codeobj__47); - Py_CLEAR(clear_module_state->__pyx_codeobj__49); - Py_CLEAR(clear_module_state->__pyx_codeobj__51); - Py_CLEAR(clear_module_state->__pyx_codeobj__53); - Py_CLEAR(clear_module_state->__pyx_codeobj__54); - Py_CLEAR(clear_module_state->__pyx_codeobj__56); - Py_CLEAR(clear_module_state->__pyx_codeobj__58); - Py_CLEAR(clear_module_state->__pyx_codeobj__60); - Py_CLEAR(clear_module_state->__pyx_codeobj__61); - Py_CLEAR(clear_module_state->__pyx_codeobj__62); - Py_CLEAR(clear_module_state->__pyx_codeobj__63); - Py_CLEAR(clear_module_state->__pyx_codeobj__65); - Py_CLEAR(clear_module_state->__pyx_codeobj__67); - Py_CLEAR(clear_module_state->__pyx_codeobj__69); - Py_CLEAR(clear_module_state->__pyx_codeobj__70); - Py_CLEAR(clear_module_state->__pyx_codeobj__71); - Py_CLEAR(clear_module_state->__pyx_codeobj__73); - Py_CLEAR(clear_module_state->__pyx_codeobj__74); - Py_CLEAR(clear_module_state->__pyx_codeobj__75); - Py_CLEAR(clear_module_state->__pyx_codeobj__76); - Py_CLEAR(clear_module_state->__pyx_codeobj__77); - Py_CLEAR(clear_module_state->__pyx_codeobj__78); - Py_CLEAR(clear_module_state->__pyx_codeobj__79); - Py_CLEAR(clear_module_state->__pyx_codeobj__81); - Py_CLEAR(clear_module_state->__pyx_codeobj__82); - Py_CLEAR(clear_module_state->__pyx_codeobj__83); - Py_CLEAR(clear_module_state->__pyx_codeobj__84); - Py_CLEAR(clear_module_state->__pyx_codeobj__85); - Py_CLEAR(clear_module_state->__pyx_codeobj__86); - Py_CLEAR(clear_module_state->__pyx_codeobj__87); - Py_CLEAR(clear_module_state->__pyx_codeobj__88); - Py_CLEAR(clear_module_state->__pyx_codeobj__89); - Py_CLEAR(clear_module_state->__pyx_codeobj__90); - Py_CLEAR(clear_module_state->__pyx_codeobj__91); - Py_CLEAR(clear_module_state->__pyx_codeobj__92); - Py_CLEAR(clear_module_state->__pyx_codeobj__93); - Py_CLEAR(clear_module_state->__pyx_codeobj__94); - Py_CLEAR(clear_module_state->__pyx_codeobj__95); - Py_CLEAR(clear_module_state->__pyx_codeobj__96); - Py_CLEAR(clear_module_state->__pyx_codeobj__97); - Py_CLEAR(clear_module_state->__pyx_codeobj__98); - Py_CLEAR(clear_module_state->__pyx_codeobj__99); - Py_CLEAR(clear_module_state->__pyx_codeobj__100); - Py_CLEAR(clear_module_state->__pyx_codeobj__101); - Py_CLEAR(clear_module_state->__pyx_codeobj__102); - Py_CLEAR(clear_module_state->__pyx_codeobj__103); - Py_CLEAR(clear_module_state->__pyx_codeobj__104); - Py_CLEAR(clear_module_state->__pyx_codeobj__105); - Py_CLEAR(clear_module_state->__pyx_codeobj__106); - Py_CLEAR(clear_module_state->__pyx_codeobj__107); - Py_CLEAR(clear_module_state->__pyx_codeobj__108); - Py_CLEAR(clear_module_state->__pyx_codeobj__109); - Py_CLEAR(clear_module_state->__pyx_codeobj__110); - Py_CLEAR(clear_module_state->__pyx_codeobj__111); - Py_CLEAR(clear_module_state->__pyx_codeobj__112); - Py_CLEAR(clear_module_state->__pyx_codeobj__113); - Py_CLEAR(clear_module_state->__pyx_codeobj__114); - Py_CLEAR(clear_module_state->__pyx_codeobj__115); - Py_CLEAR(clear_module_state->__pyx_codeobj__116); - Py_CLEAR(clear_module_state->__pyx_codeobj__117); - Py_CLEAR(clear_module_state->__pyx_codeobj__118); - Py_CLEAR(clear_module_state->__pyx_codeobj__119); - Py_CLEAR(clear_module_state->__pyx_codeobj__120); - Py_CLEAR(clear_module_state->__pyx_codeobj__121); - Py_CLEAR(clear_module_state->__pyx_codeobj__122); - Py_CLEAR(clear_module_state->__pyx_codeobj__123); - Py_CLEAR(clear_module_state->__pyx_codeobj__124); - Py_CLEAR(clear_module_state->__pyx_codeobj__125); - Py_CLEAR(clear_module_state->__pyx_codeobj__126); - Py_CLEAR(clear_module_state->__pyx_codeobj__127); - Py_CLEAR(clear_module_state->__pyx_codeobj__128); - Py_CLEAR(clear_module_state->__pyx_codeobj__129); - Py_CLEAR(clear_module_state->__pyx_codeobj__130); - Py_CLEAR(clear_module_state->__pyx_codeobj__131); - Py_CLEAR(clear_module_state->__pyx_codeobj__132); - Py_CLEAR(clear_module_state->__pyx_codeobj__133); - Py_CLEAR(clear_module_state->__pyx_codeobj__134); - Py_CLEAR(clear_module_state->__pyx_codeobj__135); - Py_CLEAR(clear_module_state->__pyx_codeobj__137); - Py_CLEAR(clear_module_state->__pyx_codeobj__138); - Py_CLEAR(clear_module_state->__pyx_codeobj__139); - Py_CLEAR(clear_module_state->__pyx_codeobj__140); - Py_CLEAR(clear_module_state->__pyx_codeobj__141); - Py_CLEAR(clear_module_state->__pyx_codeobj__142); - Py_CLEAR(clear_module_state->__pyx_codeobj__143); - Py_CLEAR(clear_module_state->__pyx_codeobj__144); - Py_CLEAR(clear_module_state->__pyx_codeobj__145); - Py_CLEAR(clear_module_state->__pyx_codeobj__146); - Py_CLEAR(clear_module_state->__pyx_codeobj__147); - Py_CLEAR(clear_module_state->__pyx_codeobj__148); - Py_CLEAR(clear_module_state->__pyx_codeobj__150); - Py_CLEAR(clear_module_state->__pyx_codeobj__152); - Py_CLEAR(clear_module_state->__pyx_codeobj__153); - Py_CLEAR(clear_module_state->__pyx_codeobj__155); - Py_CLEAR(clear_module_state->__pyx_codeobj__156); - Py_CLEAR(clear_module_state->__pyx_codeobj__157); - Py_CLEAR(clear_module_state->__pyx_codeobj__158); - Py_CLEAR(clear_module_state->__pyx_codeobj__159); - Py_CLEAR(clear_module_state->__pyx_codeobj__160); - Py_CLEAR(clear_module_state->__pyx_codeobj__161); - Py_CLEAR(clear_module_state->__pyx_codeobj__162); - Py_CLEAR(clear_module_state->__pyx_codeobj__164); - Py_CLEAR(clear_module_state->__pyx_codeobj__166); - Py_CLEAR(clear_module_state->__pyx_codeobj__168); - Py_CLEAR(clear_module_state->__pyx_codeobj__170); - Py_CLEAR(clear_module_state->__pyx_codeobj__172); - Py_CLEAR(clear_module_state->__pyx_codeobj__174); - Py_CLEAR(clear_module_state->__pyx_codeobj__175); - Py_CLEAR(clear_module_state->__pyx_codeobj__177); - Py_CLEAR(clear_module_state->__pyx_codeobj__179); - Py_CLEAR(clear_module_state->__pyx_codeobj__181); - Py_CLEAR(clear_module_state->__pyx_codeobj__182); - Py_CLEAR(clear_module_state->__pyx_codeobj__183); - Py_CLEAR(clear_module_state->__pyx_codeobj__184); - Py_CLEAR(clear_module_state->__pyx_codeobj__185); - Py_CLEAR(clear_module_state->__pyx_codeobj__187); - Py_CLEAR(clear_module_state->__pyx_codeobj__189); - Py_CLEAR(clear_module_state->__pyx_codeobj__190); - Py_CLEAR(clear_module_state->__pyx_codeobj__191); - Py_CLEAR(clear_module_state->__pyx_codeobj__192); - Py_CLEAR(clear_module_state->__pyx_codeobj__193); - Py_CLEAR(clear_module_state->__pyx_codeobj__194); - Py_CLEAR(clear_module_state->__pyx_codeobj__196); - Py_CLEAR(clear_module_state->__pyx_codeobj__197); - Py_CLEAR(clear_module_state->__pyx_codeobj__198); - Py_CLEAR(clear_module_state->__pyx_codeobj__199); - Py_CLEAR(clear_module_state->__pyx_codeobj__200); - Py_CLEAR(clear_module_state->__pyx_codeobj__201); - Py_CLEAR(clear_module_state->__pyx_codeobj__202); - Py_CLEAR(clear_module_state->__pyx_codeobj__203); - Py_CLEAR(clear_module_state->__pyx_codeobj__204); - Py_CLEAR(clear_module_state->__pyx_codeobj__206); - Py_CLEAR(clear_module_state->__pyx_codeobj__208); - Py_CLEAR(clear_module_state->__pyx_codeobj__209); - Py_CLEAR(clear_module_state->__pyx_codeobj__210); - Py_CLEAR(clear_module_state->__pyx_codeobj__211); - Py_CLEAR(clear_module_state->__pyx_codeobj__212); - Py_CLEAR(clear_module_state->__pyx_codeobj__214); - Py_CLEAR(clear_module_state->__pyx_codeobj__216); - Py_CLEAR(clear_module_state->__pyx_codeobj__218); - Py_CLEAR(clear_module_state->__pyx_codeobj__220); - Py_CLEAR(clear_module_state->__pyx_codeobj__221); - Py_CLEAR(clear_module_state->__pyx_codeobj__222); - Py_CLEAR(clear_module_state->__pyx_codeobj__224); - Py_CLEAR(clear_module_state->__pyx_codeobj__225); - Py_CLEAR(clear_module_state->__pyx_codeobj__226); - Py_CLEAR(clear_module_state->__pyx_codeobj__227); - Py_CLEAR(clear_module_state->__pyx_codeobj__229); - Py_CLEAR(clear_module_state->__pyx_codeobj__230); - Py_CLEAR(clear_module_state->__pyx_codeobj__231); - Py_CLEAR(clear_module_state->__pyx_codeobj__232); - Py_CLEAR(clear_module_state->__pyx_codeobj__233); - Py_CLEAR(clear_module_state->__pyx_codeobj__235); - Py_CLEAR(clear_module_state->__pyx_codeobj__236); - Py_CLEAR(clear_module_state->__pyx_codeobj__237); - Py_CLEAR(clear_module_state->__pyx_codeobj__238); - Py_CLEAR(clear_module_state->__pyx_codeobj__239); - Py_CLEAR(clear_module_state->__pyx_codeobj__242); - Py_CLEAR(clear_module_state->__pyx_codeobj__244); - Py_CLEAR(clear_module_state->__pyx_codeobj__245); - Py_CLEAR(clear_module_state->__pyx_codeobj__246); - Py_CLEAR(clear_module_state->__pyx_codeobj__250); - Py_CLEAR(clear_module_state->__pyx_codeobj__252); - Py_CLEAR(clear_module_state->__pyx_codeobj__253); - Py_CLEAR(clear_module_state->__pyx_codeobj__254); - Py_CLEAR(clear_module_state->__pyx_codeobj__255); - Py_CLEAR(clear_module_state->__pyx_codeobj__257); - Py_CLEAR(clear_module_state->__pyx_codeobj__259); - Py_CLEAR(clear_module_state->__pyx_codeobj__261); - Py_CLEAR(clear_module_state->__pyx_codeobj__263); - Py_CLEAR(clear_module_state->__pyx_codeobj__265); - Py_CLEAR(clear_module_state->__pyx_codeobj__267); - Py_CLEAR(clear_module_state->__pyx_codeobj__270); - Py_CLEAR(clear_module_state->__pyx_codeobj__272); - Py_CLEAR(clear_module_state->__pyx_codeobj__274); - Py_CLEAR(clear_module_state->__pyx_codeobj__276); - Py_CLEAR(clear_module_state->__pyx_codeobj__278); - Py_CLEAR(clear_module_state->__pyx_codeobj__280); - Py_CLEAR(clear_module_state->__pyx_codeobj__282); - Py_CLEAR(clear_module_state->__pyx_codeobj__284); - Py_CLEAR(clear_module_state->__pyx_codeobj__286); - Py_CLEAR(clear_module_state->__pyx_codeobj__288); - Py_CLEAR(clear_module_state->__pyx_codeobj__289); - Py_CLEAR(clear_module_state->__pyx_codeobj__290); - Py_CLEAR(clear_module_state->__pyx_codeobj__291); - Py_CLEAR(clear_module_state->__pyx_codeobj__293); - Py_CLEAR(clear_module_state->__pyx_codeobj__295); - Py_CLEAR(clear_module_state->__pyx_codeobj__297); - Py_CLEAR(clear_module_state->__pyx_codeobj__299); - Py_CLEAR(clear_module_state->__pyx_codeobj__301); - Py_CLEAR(clear_module_state->__pyx_codeobj__303); - Py_CLEAR(clear_module_state->__pyx_codeobj__304); - Py_CLEAR(clear_module_state->__pyx_codeobj__306); - Py_CLEAR(clear_module_state->__pyx_codeobj__308); - Py_CLEAR(clear_module_state->__pyx_codeobj__310); - Py_CLEAR(clear_module_state->__pyx_codeobj__312); - Py_CLEAR(clear_module_state->__pyx_codeobj__314); - Py_CLEAR(clear_module_state->__pyx_codeobj__316); - Py_CLEAR(clear_module_state->__pyx_codeobj__317); - Py_CLEAR(clear_module_state->__pyx_codeobj__319); - Py_CLEAR(clear_module_state->__pyx_codeobj__321); - Py_CLEAR(clear_module_state->__pyx_codeobj__323); - Py_CLEAR(clear_module_state->__pyx_codeobj__324); - Py_CLEAR(clear_module_state->__pyx_codeobj__325); - Py_CLEAR(clear_module_state->__pyx_codeobj__326); - Py_CLEAR(clear_module_state->__pyx_codeobj__328); - Py_CLEAR(clear_module_state->__pyx_codeobj__330); - Py_CLEAR(clear_module_state->__pyx_codeobj__332); - Py_CLEAR(clear_module_state->__pyx_codeobj__333); - Py_CLEAR(clear_module_state->__pyx_codeobj__334); - Py_CLEAR(clear_module_state->__pyx_codeobj__336); - Py_CLEAR(clear_module_state->__pyx_codeobj__337); - Py_CLEAR(clear_module_state->__pyx_codeobj__338); - Py_CLEAR(clear_module_state->__pyx_codeobj__339); - Py_CLEAR(clear_module_state->__pyx_codeobj__340); - Py_CLEAR(clear_module_state->__pyx_codeobj__341); - Py_CLEAR(clear_module_state->__pyx_codeobj__342); - Py_CLEAR(clear_module_state->__pyx_codeobj__344); - Py_CLEAR(clear_module_state->__pyx_codeobj__345); - Py_CLEAR(clear_module_state->__pyx_codeobj__346); - Py_CLEAR(clear_module_state->__pyx_codeobj__347); - Py_CLEAR(clear_module_state->__pyx_codeobj__348); - Py_CLEAR(clear_module_state->__pyx_codeobj__349); - Py_CLEAR(clear_module_state->__pyx_codeobj__350); - Py_CLEAR(clear_module_state->__pyx_codeobj__351); - Py_CLEAR(clear_module_state->__pyx_codeobj__352); - Py_CLEAR(clear_module_state->__pyx_codeobj__353); - Py_CLEAR(clear_module_state->__pyx_codeobj__354); - Py_CLEAR(clear_module_state->__pyx_codeobj__355); - Py_CLEAR(clear_module_state->__pyx_codeobj__356); - Py_CLEAR(clear_module_state->__pyx_codeobj__357); - Py_CLEAR(clear_module_state->__pyx_codeobj__358); - Py_CLEAR(clear_module_state->__pyx_codeobj__359); - Py_CLEAR(clear_module_state->__pyx_codeobj__360); - Py_CLEAR(clear_module_state->__pyx_codeobj__361); - Py_CLEAR(clear_module_state->__pyx_codeobj__362); - Py_CLEAR(clear_module_state->__pyx_codeobj__363); - Py_CLEAR(clear_module_state->__pyx_codeobj__364); - Py_CLEAR(clear_module_state->__pyx_codeobj__365); - Py_CLEAR(clear_module_state->__pyx_codeobj__366); - Py_CLEAR(clear_module_state->__pyx_codeobj__367); - Py_CLEAR(clear_module_state->__pyx_codeobj__368); - Py_CLEAR(clear_module_state->__pyx_codeobj__369); - Py_CLEAR(clear_module_state->__pyx_codeobj__370); - Py_CLEAR(clear_module_state->__pyx_codeobj__371); - Py_CLEAR(clear_module_state->__pyx_codeobj__372); - Py_CLEAR(clear_module_state->__pyx_codeobj__373); - Py_CLEAR(clear_module_state->__pyx_codeobj__374); - Py_CLEAR(clear_module_state->__pyx_codeobj__375); - Py_CLEAR(clear_module_state->__pyx_codeobj__376); - Py_CLEAR(clear_module_state->__pyx_codeobj__377); - Py_CLEAR(clear_module_state->__pyx_codeobj__378); - Py_CLEAR(clear_module_state->__pyx_codeobj__379); - Py_CLEAR(clear_module_state->__pyx_codeobj__380); - Py_CLEAR(clear_module_state->__pyx_codeobj__381); - Py_CLEAR(clear_module_state->__pyx_codeobj__382); - Py_CLEAR(clear_module_state->__pyx_codeobj__383); - Py_CLEAR(clear_module_state->__pyx_codeobj__384); - Py_CLEAR(clear_module_state->__pyx_codeobj__385); - Py_CLEAR(clear_module_state->__pyx_codeobj__386); - Py_CLEAR(clear_module_state->__pyx_codeobj__387); - Py_CLEAR(clear_module_state->__pyx_codeobj__388); - Py_CLEAR(clear_module_state->__pyx_codeobj__389); - Py_CLEAR(clear_module_state->__pyx_codeobj__390); - Py_CLEAR(clear_module_state->__pyx_codeobj__391); - Py_CLEAR(clear_module_state->__pyx_codeobj__392); - Py_CLEAR(clear_module_state->__pyx_codeobj__393); - Py_CLEAR(clear_module_state->__pyx_codeobj__394); - Py_CLEAR(clear_module_state->__pyx_codeobj__395); - Py_CLEAR(clear_module_state->__pyx_codeobj__396); - Py_CLEAR(clear_module_state->__pyx_codeobj__397); - Py_CLEAR(clear_module_state->__pyx_codeobj__398); - Py_CLEAR(clear_module_state->__pyx_codeobj__400); - Py_CLEAR(clear_module_state->__pyx_codeobj__401); - Py_CLEAR(clear_module_state->__pyx_codeobj__402); - Py_CLEAR(clear_module_state->__pyx_codeobj__403); - Py_CLEAR(clear_module_state->__pyx_codeobj__404); - Py_CLEAR(clear_module_state->__pyx_codeobj__405); - Py_CLEAR(clear_module_state->__pyx_codeobj__406); - Py_CLEAR(clear_module_state->__pyx_codeobj__407); - Py_CLEAR(clear_module_state->__pyx_codeobj__408); - Py_CLEAR(clear_module_state->__pyx_codeobj__409); - Py_CLEAR(clear_module_state->__pyx_codeobj__410); - Py_CLEAR(clear_module_state->__pyx_codeobj__411); - Py_CLEAR(clear_module_state->__pyx_codeobj__413); - Py_CLEAR(clear_module_state->__pyx_codeobj__415); - Py_CLEAR(clear_module_state->__pyx_codeobj__416); - Py_CLEAR(clear_module_state->__pyx_codeobj__418); - Py_CLEAR(clear_module_state->__pyx_codeobj__419); - Py_CLEAR(clear_module_state->__pyx_codeobj__420); - Py_CLEAR(clear_module_state->__pyx_codeobj__421); - Py_CLEAR(clear_module_state->__pyx_codeobj__422); - Py_CLEAR(clear_module_state->__pyx_codeobj__423); - Py_CLEAR(clear_module_state->__pyx_codeobj__424); - Py_CLEAR(clear_module_state->__pyx_codeobj__425); - Py_CLEAR(clear_module_state->__pyx_codeobj__427); - Py_CLEAR(clear_module_state->__pyx_codeobj__429); - Py_CLEAR(clear_module_state->__pyx_codeobj__431); - Py_CLEAR(clear_module_state->__pyx_codeobj__433); - Py_CLEAR(clear_module_state->__pyx_codeobj__435); - Py_CLEAR(clear_module_state->__pyx_codeobj__437); - Py_CLEAR(clear_module_state->__pyx_codeobj__438); - Py_CLEAR(clear_module_state->__pyx_codeobj__440); - Py_CLEAR(clear_module_state->__pyx_codeobj__442); - Py_CLEAR(clear_module_state->__pyx_codeobj__444); - Py_CLEAR(clear_module_state->__pyx_codeobj__445); - Py_CLEAR(clear_module_state->__pyx_codeobj__446); - Py_CLEAR(clear_module_state->__pyx_codeobj__447); - Py_CLEAR(clear_module_state->__pyx_codeobj__448); - Py_CLEAR(clear_module_state->__pyx_codeobj__450); - Py_CLEAR(clear_module_state->__pyx_codeobj__452); - Py_CLEAR(clear_module_state->__pyx_codeobj__453); - Py_CLEAR(clear_module_state->__pyx_codeobj__454); - Py_CLEAR(clear_module_state->__pyx_codeobj__455); - Py_CLEAR(clear_module_state->__pyx_codeobj__456); - Py_CLEAR(clear_module_state->__pyx_codeobj__457); - Py_CLEAR(clear_module_state->__pyx_codeobj__459); - Py_CLEAR(clear_module_state->__pyx_codeobj__460); - Py_CLEAR(clear_module_state->__pyx_codeobj__461); - Py_CLEAR(clear_module_state->__pyx_codeobj__462); - Py_CLEAR(clear_module_state->__pyx_codeobj__463); - Py_CLEAR(clear_module_state->__pyx_codeobj__464); - Py_CLEAR(clear_module_state->__pyx_codeobj__465); - Py_CLEAR(clear_module_state->__pyx_codeobj__466); - Py_CLEAR(clear_module_state->__pyx_codeobj__467); - Py_CLEAR(clear_module_state->__pyx_codeobj__469); - Py_CLEAR(clear_module_state->__pyx_codeobj__471); - Py_CLEAR(clear_module_state->__pyx_codeobj__472); - Py_CLEAR(clear_module_state->__pyx_codeobj__473); - Py_CLEAR(clear_module_state->__pyx_codeobj__474); - Py_CLEAR(clear_module_state->__pyx_codeobj__475); - Py_CLEAR(clear_module_state->__pyx_codeobj__477); - Py_CLEAR(clear_module_state->__pyx_codeobj__479); - Py_CLEAR(clear_module_state->__pyx_codeobj__481); - Py_CLEAR(clear_module_state->__pyx_codeobj__483); - Py_CLEAR(clear_module_state->__pyx_codeobj__484); - Py_CLEAR(clear_module_state->__pyx_codeobj__485); - Py_CLEAR(clear_module_state->__pyx_codeobj__487); - Py_CLEAR(clear_module_state->__pyx_codeobj__488); - Py_CLEAR(clear_module_state->__pyx_codeobj__489); - Py_CLEAR(clear_module_state->__pyx_codeobj__490); - Py_CLEAR(clear_module_state->__pyx_codeobj__492); - Py_CLEAR(clear_module_state->__pyx_codeobj__493); - Py_CLEAR(clear_module_state->__pyx_codeobj__494); - Py_CLEAR(clear_module_state->__pyx_codeobj__495); - Py_CLEAR(clear_module_state->__pyx_codeobj__496); - Py_CLEAR(clear_module_state->__pyx_codeobj__498); - Py_CLEAR(clear_module_state->__pyx_codeobj__499); - Py_CLEAR(clear_module_state->__pyx_codeobj__500); - Py_CLEAR(clear_module_state->__pyx_codeobj__501); - Py_CLEAR(clear_module_state->__pyx_codeobj__502); - return 0; + 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<1153; ++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 ### */ #if CYTHON_USE_MODULE_STATE -static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { - __pyx_mstate *traverse_module_state = __pyx_mstate(m); +static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); if (!traverse_module_state) return 0; Py_VISIT(traverse_module_state->__pyx_d); Py_VISIT(traverse_module_state->__pyx_b); Py_VISIT(traverse_module_state->__pyx_cython_runtime); - Py_VISIT(traverse_module_state->__pyx_empty_tuple); - Py_VISIT(traverse_module_state->__pyx_empty_bytes); - Py_VISIT(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 + __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); 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); @@ -7056,2961 +4640,196 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flexible); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_character); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ufunc); - Py_VISIT(traverse_module_state->__pyx_kp_s_3); - Py_VISIT(traverse_module_state->__pyx_n_s_ACOS); - Py_VISIT(traverse_module_state->__pyx_n_s_AD); - Py_VISIT(traverse_module_state->__pyx_n_s_ADD); - Py_VISIT(traverse_module_state->__pyx_n_s_ADOSC); - Py_VISIT(traverse_module_state->__pyx_n_s_ADX); - Py_VISIT(traverse_module_state->__pyx_n_s_ADXR); - Py_VISIT(traverse_module_state->__pyx_n_s_ALL); - Py_VISIT(traverse_module_state->__pyx_n_s_APO); - Py_VISIT(traverse_module_state->__pyx_n_s_AROON); - Py_VISIT(traverse_module_state->__pyx_n_s_AROONOSC); - Py_VISIT(traverse_module_state->__pyx_n_s_ARRAY_TYPES); - Py_VISIT(traverse_module_state->__pyx_n_s_ASIN); - Py_VISIT(traverse_module_state->__pyx_n_s_ATAN); - Py_VISIT(traverse_module_state->__pyx_n_s_ATR); - Py_VISIT(traverse_module_state->__pyx_n_s_AVGPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_AllCandleSettings); - Py_VISIT(traverse_module_state->__pyx_kp_s_Allocation_Error_TA_ALLOC_ERR); - Py_VISIT(traverse_module_state->__pyx_n_s_BBANDS); - Py_VISIT(traverse_module_state->__pyx_n_s_BETA); - Py_VISIT(traverse_module_state->__pyx_n_s_BOP); - Py_VISIT(traverse_module_state->__pyx_kp_s_Bad_Object_TA_BAD_OBJECT); - Py_VISIT(traverse_module_state->__pyx_kp_s_Bad_Parameter_TA_BAD_PARAM); - Py_VISIT(traverse_module_state->__pyx_n_s_BodyDoji); - Py_VISIT(traverse_module_state->__pyx_n_s_BodyLong); - Py_VISIT(traverse_module_state->__pyx_n_s_BodyShort); - Py_VISIT(traverse_module_state->__pyx_n_s_BodyVeryLong); - Py_VISIT(traverse_module_state->__pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut); - Py_VISIT(traverse_module_state->__pyx_n_s_CCI); - Py_VISIT(traverse_module_state->__pyx_n_s_CDL2CROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_CDL3BLACKCROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_CDL3INSIDE); - Py_VISIT(traverse_module_state->__pyx_n_s_CDL3LINESTRIKE); - Py_VISIT(traverse_module_state->__pyx_n_s_CDL3OUTSIDE); - Py_VISIT(traverse_module_state->__pyx_n_s_CDL3STARSINSOUTH); - Py_VISIT(traverse_module_state->__pyx_n_s_CDL3WHITESOLDIERS); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLABANDONEDBABY); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLADVANCEBLOCK); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLBELTHOLD); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLBREAKAWAY); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLCLOSINGMARUBOZU); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLCONCEALBABYSWALL); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLCOUNTERATTACK); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLDARKCLOUDCOVER); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLDOJISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLDRAGONFLYDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLENGULFING); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLEVENINGDOJISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLEVENINGSTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLGAPSIDESIDEWHITE); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLGRAVESTONEDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLHAMMER); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLHANGINGMAN); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLHARAMI); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLHARAMICROSS); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLHIGHWAVE); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLHIKKAKE); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLHIKKAKEMOD); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLHOMINGPIGEON); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLIDENTICAL3CROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLINNECK); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLINVERTEDHAMMER); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLKICKING); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLKICKINGBYLENGTH); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLLADDERBOTTOM); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLLONGLEGGEDDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLLONGLINE); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLMARUBOZU); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLMATCHINGLOW); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLMATHOLD); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLMORNINGDOJISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLMORNINGSTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLONNECK); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLPIERCING); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLRICKSHAWMAN); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLRISEFALL3METHODS); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLSEPARATINGLINES); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLSHOOTINGSTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLSHORTLINE); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLSPINNINGTOP); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLSTALLEDPATTERN); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLSTICKSANDWICH); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLTAKURI); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLTASUKIGAP); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLTHRUSTING); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLTRISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLUNIQUE3RIVER); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLUPSIDEGAP2CROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_CDLXSIDEGAP3METHODS); - Py_VISIT(traverse_module_state->__pyx_n_s_CEIL); - Py_VISIT(traverse_module_state->__pyx_n_s_CMO); - Py_VISIT(traverse_module_state->__pyx_n_s_CORREL); - Py_VISIT(traverse_module_state->__pyx_n_s_COS); - Py_VISIT(traverse_module_state->__pyx_n_s_COSH); - Py_VISIT(traverse_module_state->__pyx_n_s_CandleSettingType); - Py_VISIT(traverse_module_state->__pyx_n_s_DEMA); - Py_VISIT(traverse_module_state->__pyx_n_s_DIV); - Py_VISIT(traverse_module_state->__pyx_n_s_DX); - Py_VISIT(traverse_module_state->__pyx_kp_s_Dashed_Line); - Py_VISIT(traverse_module_state->__pyx_n_s_DataFrame); - Py_VISIT(traverse_module_state->__pyx_n_s_Dot); - Py_VISIT(traverse_module_state->__pyx_kp_s_Dotted_Line); - Py_VISIT(traverse_module_state->__pyx_kp_s_Double_Exponential_Moving_Averag); - Py_VISIT(traverse_module_state->__pyx_n_s_EMA); - Py_VISIT(traverse_module_state->__pyx_n_s_EXP); - Py_VISIT(traverse_module_state->__pyx_n_s_Equal); - Py_VISIT(traverse_module_state->__pyx_kp_s_Exponential_Moving_Average); - Py_VISIT(traverse_module_state->__pyx_n_s_FLOOR); - Py_VISIT(traverse_module_state->__pyx_n_s_Far); - Py_VISIT(traverse_module_state->__pyx_n_s_Function); - Py_VISIT(traverse_module_state->__pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___call); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___call_function); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___check_opt_input_value); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___get_opt_input_value); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___init); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___input_price_series_na); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___local); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___repr); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___str); - Py_VISIT(traverse_module_state->__pyx_n_s_Function___unicode); - Py_VISIT(traverse_module_state->__pyx_n_s_Function__call_function); - Py_VISIT(traverse_module_state->__pyx_n_s_Function__check_opt_input_value); - Py_VISIT(traverse_module_state->__pyx_n_s_Function__get_opt_input_value); - Py_VISIT(traverse_module_state->__pyx_n_s_Function__input_price_series_na); - Py_VISIT(traverse_module_state->__pyx_n_s_Function__local); - Py_VISIT(traverse_module_state->__pyx_n_s_Function__localdata); - Py_VISIT(traverse_module_state->__pyx_n_s_Function__name); - Py_VISIT(traverse_module_state->__pyx_n_s_Function__namestr); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_function_flags); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_get_input_arrays); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_get_input_names); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_get_parameters); - Py_VISIT(traverse_module_state->__pyx_kp_s_Function_has_an_unstable_period); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_info); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_lookback); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_output_flags); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_output_names); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_outputs); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_run); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_set_function_args); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_set_input_arrays); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_set_input_names); - Py_VISIT(traverse_module_state->__pyx_n_s_Function_set_parameters); - Py_VISIT(traverse_module_state->__pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU); - Py_VISIT(traverse_module_state->__pyx_n_s_HT_DCPERIOD); - Py_VISIT(traverse_module_state->__pyx_n_s_HT_DCPHASE); - Py_VISIT(traverse_module_state->__pyx_n_s_HT_PHASOR); - Py_VISIT(traverse_module_state->__pyx_n_s_HT_SINE); - Py_VISIT(traverse_module_state->__pyx_n_s_HT_TRENDLINE); - Py_VISIT(traverse_module_state->__pyx_n_s_HT_TRENDMODE); - Py_VISIT(traverse_module_state->__pyx_n_s_HighLow); - Py_VISIT(traverse_module_state->__pyx_n_s_Histogram); - Py_VISIT(traverse_module_state->__pyx_n_s_INPUT_ARRAYS_TYPES); - Py_VISIT(traverse_module_state->__pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS); - Py_VISIT(traverse_module_state->__pyx_n_s_ImportError); - Py_VISIT(traverse_module_state->__pyx_n_s_IndexError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Input_Not_All_Initialized_TA_INP); - Py_VISIT(traverse_module_state->__pyx_kp_s_Inputs); - Py_VISIT(traverse_module_state->__pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR); - Py_VISIT(traverse_module_state->__pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE); - Py_VISIT(traverse_module_state->__pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS); - Py_VISIT(traverse_module_state->__pyx_kp_s_Invalid_Parameter_Function_TA_IN); - Py_VISIT(traverse_module_state->__pyx_kp_s_Invalid_Parameter_Holder_TA_INVA); - Py_VISIT(traverse_module_state->__pyx_kp_s_Invalid_Parameter_Holder_Type_TA); - Py_VISIT(traverse_module_state->__pyx_kp_s_Invalid_parameter_value_for_s_ex); - Py_VISIT(traverse_module_state->__pyx_n_s_KAMA); - Py_VISIT(traverse_module_state->__pyx_kp_s_Kaufman_Adaptive_Moving_Average); - Py_VISIT(traverse_module_state->__pyx_n_s_LINEARREG); - Py_VISIT(traverse_module_state->__pyx_n_s_LINEARREG_ANGLE); - Py_VISIT(traverse_module_state->__pyx_n_s_LINEARREG_INTERCEPT); - Py_VISIT(traverse_module_state->__pyx_n_s_LINEARREG_SLOPE); - Py_VISIT(traverse_module_state->__pyx_n_s_LN); - Py_VISIT(traverse_module_state->__pyx_n_s_LOG10); - Py_VISIT(traverse_module_state->__pyx_kp_s_Library_Not_Initialized_TA_LIB_N); - Py_VISIT(traverse_module_state->__pyx_n_s_Line); - Py_VISIT(traverse_module_state->__pyx_n_s_MA); - Py_VISIT(traverse_module_state->__pyx_n_s_MACD); - Py_VISIT(traverse_module_state->__pyx_n_s_MACDEXT); - Py_VISIT(traverse_module_state->__pyx_n_s_MACDFIX); - Py_VISIT(traverse_module_state->__pyx_n_s_MAMA); - Py_VISIT(traverse_module_state->__pyx_n_s_MAVP); - Py_VISIT(traverse_module_state->__pyx_n_s_MAX); - Py_VISIT(traverse_module_state->__pyx_n_s_MAXINDEX); - Py_VISIT(traverse_module_state->__pyx_n_s_MA_Type); - Py_VISIT(traverse_module_state->__pyx_n_s_MA_Type___getitem); - Py_VISIT(traverse_module_state->__pyx_n_s_MA_Type___init); - Py_VISIT(traverse_module_state->__pyx_n_s_MEDPRICE); - Py_VISIT(traverse_module_state->__pyx_kp_s_MESA_Adaptive_Moving_Average); - Py_VISIT(traverse_module_state->__pyx_n_s_MFI); - Py_VISIT(traverse_module_state->__pyx_n_s_MIDPOINT); - Py_VISIT(traverse_module_state->__pyx_n_s_MIDPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_MIN); - Py_VISIT(traverse_module_state->__pyx_n_s_MININDEX); - Py_VISIT(traverse_module_state->__pyx_n_s_MINMAX); - Py_VISIT(traverse_module_state->__pyx_n_s_MINMAXINDEX); - Py_VISIT(traverse_module_state->__pyx_n_s_MINUS_DI); - Py_VISIT(traverse_module_state->__pyx_n_s_MINUS_DM); - Py_VISIT(traverse_module_state->__pyx_n_s_MOM); - Py_VISIT(traverse_module_state->__pyx_n_s_MULT); - Py_VISIT(traverse_module_state->__pyx_n_s_NATR); - Py_VISIT(traverse_module_state->__pyx_n_s_NONE); - Py_VISIT(traverse_module_state->__pyx_n_s_Near); - Py_VISIT(traverse_module_state->__pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED); - Py_VISIT(traverse_module_state->__pyx_kp_s_Not_enough_price_arguments_expec); - Py_VISIT(traverse_module_state->__pyx_n_s_OBV); - Py_VISIT(traverse_module_state->__pyx_n_s_OrderedDict); - Py_VISIT(traverse_module_state->__pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF); - Py_VISIT(traverse_module_state->__pyx_kp_s_Out_of_Range_Start_Index_TA_OUT); - Py_VISIT(traverse_module_state->__pyx_kp_s_Output_Not_All_Initialized_TA_OU); - Py_VISIT(traverse_module_state->__pyx_kp_s_Output_can_be_negative); - Py_VISIT(traverse_module_state->__pyx_kp_s_Output_can_be_positive); - Py_VISIT(traverse_module_state->__pyx_kp_s_Output_can_be_zero); - Py_VISIT(traverse_module_state->__pyx_kp_s_Output_is_a_candlestick); - Py_VISIT(traverse_module_state->__pyx_kp_s_Output_is_over_volume); - Py_VISIT(traverse_module_state->__pyx_kp_s_Output_scale_same_as_input); - Py_VISIT(traverse_module_state->__pyx_kp_s_Outputs); - Py_VISIT(traverse_module_state->__pyx_n_s_PANDAS_DATAFRAME); - Py_VISIT(traverse_module_state->__pyx_n_s_PANDAS_SERIES); - Py_VISIT(traverse_module_state->__pyx_n_s_PLUS_DI); - Py_VISIT(traverse_module_state->__pyx_n_s_PLUS_DM); - Py_VISIT(traverse_module_state->__pyx_n_s_POLARS_DATAFRAME); - Py_VISIT(traverse_module_state->__pyx_n_s_POLARS_SERIES); - Py_VISIT(traverse_module_state->__pyx_n_s_PPO); - Py_VISIT(traverse_module_state->__pyx_kp_s_Parameters); - Py_VISIT(traverse_module_state->__pyx_kp_s_Pattern_Bool); - Py_VISIT(traverse_module_state->__pyx_n_s_ROC); - Py_VISIT(traverse_module_state->__pyx_n_s_ROCP); - Py_VISIT(traverse_module_state->__pyx_n_s_ROCR); - Py_VISIT(traverse_module_state->__pyx_n_s_ROCR100); - Py_VISIT(traverse_module_state->__pyx_n_s_RSI); - Py_VISIT(traverse_module_state->__pyx_n_s_RangeType); - Py_VISIT(traverse_module_state->__pyx_n_s_RealBody); - Py_VISIT(traverse_module_state->__pyx_n_s_SAR); - Py_VISIT(traverse_module_state->__pyx_n_s_SAREXT); - Py_VISIT(traverse_module_state->__pyx_n_s_SIN); - Py_VISIT(traverse_module_state->__pyx_n_s_SINH); - Py_VISIT(traverse_module_state->__pyx_n_s_SMA); - Py_VISIT(traverse_module_state->__pyx_n_s_SQRT); - Py_VISIT(traverse_module_state->__pyx_n_s_STDDEV); - Py_VISIT(traverse_module_state->__pyx_n_s_STOCH); - Py_VISIT(traverse_module_state->__pyx_n_s_STOCHF); - Py_VISIT(traverse_module_state->__pyx_n_s_STOCHRSI); - Py_VISIT(traverse_module_state->__pyx_n_s_SUB); - Py_VISIT(traverse_module_state->__pyx_n_s_SUM); - Py_VISIT(traverse_module_state->__pyx_n_s_Series); - Py_VISIT(traverse_module_state->__pyx_n_s_ShadowLong); - Py_VISIT(traverse_module_state->__pyx_n_s_ShadowShort); - Py_VISIT(traverse_module_state->__pyx_n_s_ShadowVeryLong); - Py_VISIT(traverse_module_state->__pyx_n_s_ShadowVeryShort); - Py_VISIT(traverse_module_state->__pyx_n_s_Shadows); - Py_VISIT(traverse_module_state->__pyx_kp_s_Simple_Moving_Average); - Py_VISIT(traverse_module_state->__pyx_kp_s_Strength_Pattern_200_100_Bearish); - Py_VISIT(traverse_module_state->__pyx_n_s_T3); - Py_VISIT(traverse_module_state->__pyx_n_s_TAN); - Py_VISIT(traverse_module_state->__pyx_n_s_TANH); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ACOS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_AD); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ADD); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ADOSC); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ADX); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ADXR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_APO); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_AROON); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_AROONOSC); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ASIN); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ATAN); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ATR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_AVGPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_BBANDS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_BETA); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_BOP); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CCI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDL2CROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDL3BLACKCROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDL3INSIDE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDL3LINESTRIKE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDL3OUTSIDE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDL3STARSINSOUTH); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDL3WHITESOLDIERS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLABANDONEDBABY); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLADVANCEBLOCK); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLBELTHOLD); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLBREAKAWAY); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLCLOSINGMARUBOZU); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLCONCEALBABYSWALL); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLCOUNTERATTACK); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLDARKCLOUDCOVER); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLDOJISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLDRAGONFLYDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLENGULFING); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLEVENINGDOJISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLEVENINGSTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLGAPSIDESIDEWHITE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLGRAVESTONEDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLHAMMER); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLHANGINGMAN); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLHARAMI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLHARAMICROSS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLHIGHWAVE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLHIKKAKE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLHIKKAKEMOD); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLHOMINGPIGEON); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLIDENTICAL3CROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLINNECK); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLINVERTEDHAMMER); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLKICKING); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLKICKINGBYLENGTH); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLLADDERBOTTOM); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLLONGLEGGEDDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLLONGLINE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLMARUBOZU); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLMATCHINGLOW); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLMATHOLD); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLMORNINGDOJISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLMORNINGSTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLONNECK); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLPIERCING); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLRICKSHAWMAN); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLRISEFALL3METHODS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLSEPARATINGLINES); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLSHOOTINGSTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLSHORTLINE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLSPINNINGTOP); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLSTALLEDPATTERN); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLSTICKSANDWICH); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLTAKURI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLTASUKIGAP); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLTHRUSTING); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLTRISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLUNIQUE3RIVER); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLUPSIDEGAP2CROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CDLXSIDEGAP3METHODS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CEIL); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CMO); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_CORREL); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_COS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_COSH); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_DEMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_DIV); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_DX); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_EMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_EXP); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_FLOOR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_FUNCTION_NAMES); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_FUNC_FLAGS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_FuncTableAlloc); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_FuncTableFree); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_GetFuncHandle); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_GetFuncInfo); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_GetInputParameterInfo); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_GetLookback); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_GetOptInputParameterInfo); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_GetOutputParameterInfo); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_GroupTableAlloc); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_GroupTableFree); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_HT_DCPERIOD); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_HT_DCPHASE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_HT_PHASOR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_HT_SINE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_HT_TRENDLINE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_HT_TRENDMODE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_INPUT_FLAGS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_Initialize); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_KAMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_LINEARREG); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_LINEARREG_ANGLE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_LINEARREG_INTERCEPT); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_LINEARREG_SLOPE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_LN); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_LOG10); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MA); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MACD); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MACDEXT); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MACDFIX); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MAMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MAVP); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MAX); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MAXINDEX); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MEDPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MFI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MIDPOINT); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MIDPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MIN); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MININDEX); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MINMAX); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MINMAXINDEX); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MINUS_DI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MINUS_DM); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MOM); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_MULT); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_NATR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_OBV); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_OUTPUT_FLAGS); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_PLUS_DI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_PLUS_DM); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_PPO); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ParamHolderAlloc); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ParamHolderFree); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ROC); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ROCP); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ROCR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ROCR100); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_RSI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_RestoreCandleDefaultSettings); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SAR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SAREXT); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SIN); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SINH); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SQRT); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_STDDEV); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_STOCH); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_STOCHF); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_STOCHRSI); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SUB); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SUM); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SetCandleSettings); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SetCompatibility); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SetOptInputParamInteger); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SetOptInputParamReal); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_SetUnstablePeriod); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_Shutdown); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_T3); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_TAN); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_TANH); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_TEMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_TRANGE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_TRIMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_TRIX); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_TSF); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_TYPPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_ULTOSC); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_VAR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_WCLPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_WILLR); - Py_VISIT(traverse_module_state->__pyx_n_s_TA_WMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TEMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TRANGE); - Py_VISIT(traverse_module_state->__pyx_n_s_TRIMA); - Py_VISIT(traverse_module_state->__pyx_n_s_TRIX); - Py_VISIT(traverse_module_state->__pyx_n_s_TSF); - Py_VISIT(traverse_module_state->__pyx_n_s_TYPPRICE); - Py_VISIT(traverse_module_state->__pyx_kp_s_This_is_a_pythonic_wrapper_arou); - Py_VISIT(traverse_module_state->__pyx_kp_s_Too_many_price_arguments_expecte); - Py_VISIT(traverse_module_state->__pyx_kp_s_Triangular_Moving_Average); - Py_VISIT(traverse_module_state->__pyx_kp_s_Triple_Exponential_Moving_Averag); - Py_VISIT(traverse_module_state->__pyx_kp_s_Triple_Generalized_Double_Expone); - Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); - Py_VISIT(traverse_module_state->__pyx_n_s_ULTOSC); - Py_VISIT(traverse_module_state->__pyx_kp_s_Unknown_Error); - Py_VISIT(traverse_module_state->__pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR); - Py_VISIT(traverse_module_state->__pyx_n_s_VAR); - Py_VISIT(traverse_module_state->__pyx_kp_s_Values_represent_a_lower_limit); - Py_VISIT(traverse_module_state->__pyx_kp_s_Values_represent_an_upper_limit); - Py_VISIT(traverse_module_state->__pyx_n_s_WCLPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_WILLR); - Py_VISIT(traverse_module_state->__pyx_n_s_WMA); - Py_VISIT(traverse_module_state->__pyx_kp_s_Weighted_Moving_Average); - Py_VISIT(traverse_module_state->__pyx_kp_s__10); - Py_VISIT(traverse_module_state->__pyx_kp_s__11); - Py_VISIT(traverse_module_state->__pyx_kp_s__12); - Py_VISIT(traverse_module_state->__pyx_n_s__240); - Py_VISIT(traverse_module_state->__pyx_kp_u__43); - Py_VISIT(traverse_module_state->__pyx_n_s__503); - Py_VISIT(traverse_module_state->__pyx_kp_s__6); - Py_VISIT(traverse_module_state->__pyx_kp_s__7); - Py_VISIT(traverse_module_state->__pyx_kp_s__9); - Py_VISIT(traverse_module_state->__pyx_n_s_acceleration); - Py_VISIT(traverse_module_state->__pyx_n_s_accelerationinitlong); - Py_VISIT(traverse_module_state->__pyx_n_s_accelerationinitshort); - Py_VISIT(traverse_module_state->__pyx_n_s_accelerationlong); - Py_VISIT(traverse_module_state->__pyx_n_s_accelerationmaxlong); - Py_VISIT(traverse_module_state->__pyx_n_s_accelerationmaxshort); - Py_VISIT(traverse_module_state->__pyx_n_s_accelerationshort); - Py_VISIT(traverse_module_state->__pyx_n_s_all); - Py_VISIT(traverse_module_state->__pyx_kp_s_any_ndarray); - Py_VISIT(traverse_module_state->__pyx_n_s_append); - Py_VISIT(traverse_module_state->__pyx_n_s_arg); - Py_VISIT(traverse_module_state->__pyx_n_s_args); - Py_VISIT(traverse_module_state->__pyx_n_s_ascii); - Py_VISIT(traverse_module_state->__pyx_n_s_astype); - Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); - Py_VISIT(traverse_module_state->__pyx_n_s_avgperiod); - Py_VISIT(traverse_module_state->__pyx_n_s_b); - Py_VISIT(traverse_module_state->__pyx_n_s_begidx); - Py_VISIT(traverse_module_state->__pyx_n_s_bytes2str); - Py_VISIT(traverse_module_state->__pyx_n_s_call); - Py_VISIT(traverse_module_state->__pyx_n_s_call_function); - Py_VISIT(traverse_module_state->__pyx_n_s_check_opt_input_value); - Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem); - Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); - Py_VISIT(traverse_module_state->__pyx_n_s_clone); - Py_VISIT(traverse_module_state->__pyx_n_s_close); - Py_VISIT(traverse_module_state->__pyx_n_s_close_data); - Py_VISIT(traverse_module_state->__pyx_n_s_collections); - Py_VISIT(traverse_module_state->__pyx_n_s_column_stack); - Py_VISIT(traverse_module_state->__pyx_n_s_columns); - Py_VISIT(traverse_module_state->__pyx_n_s_copy); - Py_VISIT(traverse_module_state->__pyx_n_s_decode); - Py_VISIT(traverse_module_state->__pyx_n_s_default_value); - Py_VISIT(traverse_module_state->__pyx_n_s_defaults); - Py_VISIT(traverse_module_state->__pyx_n_s_dict); - Py_VISIT(traverse_module_state->__pyx_n_s_display_name); - Py_VISIT(traverse_module_state->__pyx_kp_s_display_name_s_group_s); - Py_VISIT(traverse_module_state->__pyx_n_s_doc); - Py_VISIT(traverse_module_state->__pyx_n_s_docs); - Py_VISIT(traverse_module_state->__pyx_n_s_documentation); - Py_VISIT(traverse_module_state->__pyx_n_s_empty); - Py_VISIT(traverse_module_state->__pyx_n_s_endidx); - Py_VISIT(traverse_module_state->__pyx_n_s_enumerate); - Py_VISIT(traverse_module_state->__pyx_n_s_factor); - Py_VISIT(traverse_module_state->__pyx_n_s_fastd_matype); - Py_VISIT(traverse_module_state->__pyx_n_s_fastd_period); - Py_VISIT(traverse_module_state->__pyx_n_s_fastk_period); - Py_VISIT(traverse_module_state->__pyx_n_s_fastlimit); - Py_VISIT(traverse_module_state->__pyx_n_s_fastmatype); - Py_VISIT(traverse_module_state->__pyx_n_s_fastperiod); - Py_VISIT(traverse_module_state->__pyx_n_s_flag); - Py_VISIT(traverse_module_state->__pyx_n_s_flags); - Py_VISIT(traverse_module_state->__pyx_n_s_flags_lookup_dict); - Py_VISIT(traverse_module_state->__pyx_n_s_func_args); - Py_VISIT(traverse_module_state->__pyx_n_s_func_info); - Py_VISIT(traverse_module_state->__pyx_n_s_func_line); - Py_VISIT(traverse_module_state->__pyx_n_s_func_object); - Py_VISIT(traverse_module_state->__pyx_n_s_function_flags); - Py_VISIT(traverse_module_state->__pyx_n_s_function_name); - Py_VISIT(traverse_module_state->__pyx_n_s_functions); - Py_VISIT(traverse_module_state->__pyx_n_s_get_defaults_and_docs); - Py_VISIT(traverse_module_state->__pyx_n_s_get_flags); - Py_VISIT(traverse_module_state->__pyx_n_s_get_input_arrays); - Py_VISIT(traverse_module_state->__pyx_n_s_get_input_names); - Py_VISIT(traverse_module_state->__pyx_n_s_get_opt_input_value); - Py_VISIT(traverse_module_state->__pyx_n_s_get_parameters); - Py_VISIT(traverse_module_state->__pyx_n_s_getitem); - Py_VISIT(traverse_module_state->__pyx_n_s_group); - Py_VISIT(traverse_module_state->__pyx_n_s_groups); - Py_VISIT(traverse_module_state->__pyx_n_s_help); - Py_VISIT(traverse_module_state->__pyx_n_s_high); - Py_VISIT(traverse_module_state->__pyx_n_s_high_data); - Py_VISIT(traverse_module_state->__pyx_n_s_holder); - Py_VISIT(traverse_module_state->__pyx_n_s_i); - Py_VISIT(traverse_module_state->__pyx_n_s_id); - Py_VISIT(traverse_module_state->__pyx_n_s_idx); - Py_VISIT(traverse_module_state->__pyx_n_s_import); - Py_VISIT(traverse_module_state->__pyx_n_s_in); - Py_VISIT(traverse_module_state->__pyx_n_s_index); - Py_VISIT(traverse_module_state->__pyx_n_s_info); - Py_VISIT(traverse_module_state->__pyx_n_s_init); - Py_VISIT(traverse_module_state->__pyx_n_s_init_subclass); - Py_VISIT(traverse_module_state->__pyx_n_s_initializing); - Py_VISIT(traverse_module_state->__pyx_kp_s_input_array_has_wrong_dimensions); - Py_VISIT(traverse_module_state->__pyx_kp_s_input_array_lengths_are_differen); - Py_VISIT(traverse_module_state->__pyx_kp_s_input_array_type_is_not_double); - Py_VISIT(traverse_module_state->__pyx_n_s_input_arrays); - Py_VISIT(traverse_module_state->__pyx_kp_s_input_arrays_2); - Py_VISIT(traverse_module_state->__pyx_kp_s_input_arrays_parameter_missing_r); - Py_VISIT(traverse_module_state->__pyx_n_s_input_name); - Py_VISIT(traverse_module_state->__pyx_n_s_input_names); - Py_VISIT(traverse_module_state->__pyx_n_s_input_price_series_names); - Py_VISIT(traverse_module_state->__pyx_n_s_input_price_series_names_2); - Py_VISIT(traverse_module_state->__pyx_n_s_integer); - Py_VISIT(traverse_module_state->__pyx_kp_s_integer_values_are_100_0_or_100); - Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); - Py_VISIT(traverse_module_state->__pyx_n_s_is_empty); - Py_VISIT(traverse_module_state->__pyx_n_s_items); - Py_VISIT(traverse_module_state->__pyx_n_s_join); - Py_VISIT(traverse_module_state->__pyx_n_s_key); - Py_VISIT(traverse_module_state->__pyx_n_s_keys); - Py_VISIT(traverse_module_state->__pyx_n_s_kwargs); - Py_VISIT(traverse_module_state->__pyx_n_s_length); - Py_VISIT(traverse_module_state->__pyx_n_s_local); - Py_VISIT(traverse_module_state->__pyx_n_s_local_2); - Py_VISIT(traverse_module_state->__pyx_n_s_log); - Py_VISIT(traverse_module_state->__pyx_n_s_lookback); - Py_VISIT(traverse_module_state->__pyx_n_s_lookup); - Py_VISIT(traverse_module_state->__pyx_n_s_low); - Py_VISIT(traverse_module_state->__pyx_n_s_low_data); - Py_VISIT(traverse_module_state->__pyx_n_s_lower); - Py_VISIT(traverse_module_state->__pyx_n_s_main); - Py_VISIT(traverse_module_state->__pyx_n_s_math); - Py_VISIT(traverse_module_state->__pyx_n_s_matype); - Py_VISIT(traverse_module_state->__pyx_n_s_max); - Py_VISIT(traverse_module_state->__pyx_n_s_max_int); - Py_VISIT(traverse_module_state->__pyx_n_s_maximum); - Py_VISIT(traverse_module_state->__pyx_n_s_maxperiod); - Py_VISIT(traverse_module_state->__pyx_n_s_metaclass); - Py_VISIT(traverse_module_state->__pyx_n_s_min); - Py_VISIT(traverse_module_state->__pyx_n_s_min_int); - Py_VISIT(traverse_module_state->__pyx_n_s_minperiod); - Py_VISIT(traverse_module_state->__pyx_n_s_missing); - Py_VISIT(traverse_module_state->__pyx_n_s_missing_keys); - Py_VISIT(traverse_module_state->__pyx_n_s_module); - Py_VISIT(traverse_module_state->__pyx_n_s_mro_entries); - Py_VISIT(traverse_module_state->__pyx_n_s_msg); - Py_VISIT(traverse_module_state->__pyx_n_s_n); - Py_VISIT(traverse_module_state->__pyx_n_s_name); - Py_VISIT(traverse_module_state->__pyx_n_s_name_2); - Py_VISIT(traverse_module_state->__pyx_n_s_nan); - Py_VISIT(traverse_module_state->__pyx_n_s_nbdev); - Py_VISIT(traverse_module_state->__pyx_n_s_nbdevdn); - Py_VISIT(traverse_module_state->__pyx_n_s_nbdevup); - Py_VISIT(traverse_module_state->__pyx_n_s_no_existing_input_arrays); - Py_VISIT(traverse_module_state->__pyx_n_s_num_inputs); - Py_VISIT(traverse_module_state->__pyx_n_s_num_opt_inputs); - Py_VISIT(traverse_module_state->__pyx_n_s_num_outputs); - Py_VISIT(traverse_module_state->__pyx_n_s_numpy); - Py_VISIT(traverse_module_state->__pyx_kp_s_numpy_core_multiarray_failed_to); - Py_VISIT(traverse_module_state->__pyx_kp_s_numpy_core_umath_failed_to_impor); - Py_VISIT(traverse_module_state->__pyx_n_s_object); - Py_VISIT(traverse_module_state->__pyx_n_s_offsetonreverse); - Py_VISIT(traverse_module_state->__pyx_n_s_open); - Py_VISIT(traverse_module_state->__pyx_n_s_openInterest); - Py_VISIT(traverse_module_state->__pyx_n_s_open_data); - Py_VISIT(traverse_module_state->__pyx_n_s_optIn); - Py_VISIT(traverse_module_state->__pyx_n_s_opt_input); - Py_VISIT(traverse_module_state->__pyx_n_s_opt_input_values); - Py_VISIT(traverse_module_state->__pyx_n_s_opt_inputs); - Py_VISIT(traverse_module_state->__pyx_n_s_ordereddict); - Py_VISIT(traverse_module_state->__pyx_n_s_out); - Py_VISIT(traverse_module_state->__pyx_n_s_outaroondown); - Py_VISIT(traverse_module_state->__pyx_n_s_outaroonup); - Py_VISIT(traverse_module_state->__pyx_n_s_outbegidx); - Py_VISIT(traverse_module_state->__pyx_n_s_outfama); - Py_VISIT(traverse_module_state->__pyx_n_s_outfastd); - Py_VISIT(traverse_module_state->__pyx_n_s_outfastk); - Py_VISIT(traverse_module_state->__pyx_n_s_outinphase); - Py_VISIT(traverse_module_state->__pyx_n_s_outinteger); - Py_VISIT(traverse_module_state->__pyx_n_s_outinteger_data); - Py_VISIT(traverse_module_state->__pyx_n_s_outleadsine); - Py_VISIT(traverse_module_state->__pyx_n_s_outmacd); - Py_VISIT(traverse_module_state->__pyx_n_s_outmacdhist); - Py_VISIT(traverse_module_state->__pyx_n_s_outmacdsignal); - Py_VISIT(traverse_module_state->__pyx_n_s_outmama); - Py_VISIT(traverse_module_state->__pyx_n_s_outmax); - Py_VISIT(traverse_module_state->__pyx_n_s_outmaxidx); - Py_VISIT(traverse_module_state->__pyx_n_s_outmaxidx_data); - Py_VISIT(traverse_module_state->__pyx_n_s_outmin); - Py_VISIT(traverse_module_state->__pyx_n_s_outminidx); - Py_VISIT(traverse_module_state->__pyx_n_s_outminidx_data); - Py_VISIT(traverse_module_state->__pyx_n_s_outnbelement); - Py_VISIT(traverse_module_state->__pyx_n_s_output); - Py_VISIT(traverse_module_state->__pyx_n_s_output_flags); - Py_VISIT(traverse_module_state->__pyx_n_s_output_name); - Py_VISIT(traverse_module_state->__pyx_n_s_output_names); - Py_VISIT(traverse_module_state->__pyx_n_s_outputs); - Py_VISIT(traverse_module_state->__pyx_n_s_outputs_valid); - Py_VISIT(traverse_module_state->__pyx_n_s_outquadrature); - Py_VISIT(traverse_module_state->__pyx_n_s_outreal); - Py_VISIT(traverse_module_state->__pyx_n_s_outreallowerband); - Py_VISIT(traverse_module_state->__pyx_n_s_outrealmiddleband); - Py_VISIT(traverse_module_state->__pyx_n_s_outrealupperband); - Py_VISIT(traverse_module_state->__pyx_n_s_outsine); - Py_VISIT(traverse_module_state->__pyx_n_s_outslowd); - Py_VISIT(traverse_module_state->__pyx_n_s_outslowk); - Py_VISIT(traverse_module_state->__pyx_n_s_pandas); - Py_VISIT(traverse_module_state->__pyx_n_s_param); - Py_VISIT(traverse_module_state->__pyx_n_s_param_name); - Py_VISIT(traverse_module_state->__pyx_n_s_parameters); - Py_VISIT(traverse_module_state->__pyx_n_s_params); - Py_VISIT(traverse_module_state->__pyx_n_s_penetration); - Py_VISIT(traverse_module_state->__pyx_n_s_period); - Py_VISIT(traverse_module_state->__pyx_n_s_periods); - Py_VISIT(traverse_module_state->__pyx_n_s_periods_data); - Py_VISIT(traverse_module_state->__pyx_n_s_polars); - Py_VISIT(traverse_module_state->__pyx_n_s_pop); - Py_VISIT(traverse_module_state->__pyx_n_s_prepare); - Py_VISIT(traverse_module_state->__pyx_n_s_price); - Py_VISIT(traverse_module_state->__pyx_n_s_price0); - Py_VISIT(traverse_module_state->__pyx_n_s_price1); - Py_VISIT(traverse_module_state->__pyx_n_s_price_series); - Py_VISIT(traverse_module_state->__pyx_n_s_price_series_name_values); - Py_VISIT(traverse_module_state->__pyx_n_s_prices); - Py_VISIT(traverse_module_state->__pyx_n_s_property); - Py_VISIT(traverse_module_state->__pyx_n_s_qualname); - Py_VISIT(traverse_module_state->__pyx_n_s_range); - Py_VISIT(traverse_module_state->__pyx_n_s_rangetype); - Py_VISIT(traverse_module_state->__pyx_n_s_real); - Py_VISIT(traverse_module_state->__pyx_n_s_real0); - Py_VISIT(traverse_module_state->__pyx_n_s_real0_data); - Py_VISIT(traverse_module_state->__pyx_n_s_real1); - Py_VISIT(traverse_module_state->__pyx_n_s_real1_data); - Py_VISIT(traverse_module_state->__pyx_n_s_real_data); - Py_VISIT(traverse_module_state->__pyx_n_s_replace); - Py_VISIT(traverse_module_state->__pyx_n_s_repr); - Py_VISIT(traverse_module_state->__pyx_n_s_results); - Py_VISIT(traverse_module_state->__pyx_n_s_ret); - Py_VISIT(traverse_module_state->__pyx_n_s_retCode); - Py_VISIT(traverse_module_state->__pyx_n_s_ret_code); - Py_VISIT(traverse_module_state->__pyx_n_s_run); - Py_VISIT(traverse_module_state->__pyx_n_s_s); - Py_VISIT(traverse_module_state->__pyx_kp_s_s_2); - Py_VISIT(traverse_module_state->__pyx_kp_s_s_3); - Py_VISIT(traverse_module_state->__pyx_kp_s_s_4); - Py_VISIT(traverse_module_state->__pyx_kp_s_s_function_failed_with_error_co); - Py_VISIT(traverse_module_state->__pyx_kp_s_s_s); - Py_VISIT(traverse_module_state->__pyx_kp_s_s_s_2); - Py_VISIT(traverse_module_state->__pyx_n_s_schema); - Py_VISIT(traverse_module_state->__pyx_n_s_self); - Py_VISIT(traverse_module_state->__pyx_n_s_series); - Py_VISIT(traverse_module_state->__pyx_n_s_set_function_args); - Py_VISIT(traverse_module_state->__pyx_n_s_set_input_arrays); - Py_VISIT(traverse_module_state->__pyx_n_s_set_input_names); - Py_VISIT(traverse_module_state->__pyx_n_s_set_name); - Py_VISIT(traverse_module_state->__pyx_n_s_set_parameters); - Py_VISIT(traverse_module_state->__pyx_n_s_settingtype); - Py_VISIT(traverse_module_state->__pyx_n_s_signalmatype); - Py_VISIT(traverse_module_state->__pyx_n_s_signalperiod); - Py_VISIT(traverse_module_state->__pyx_n_s_skip_first); - Py_VISIT(traverse_module_state->__pyx_n_s_slowd_matype); - Py_VISIT(traverse_module_state->__pyx_n_s_slowd_period); - Py_VISIT(traverse_module_state->__pyx_n_s_slowk_matype); - Py_VISIT(traverse_module_state->__pyx_n_s_slowk_period); - Py_VISIT(traverse_module_state->__pyx_n_s_slowlimit); - Py_VISIT(traverse_module_state->__pyx_n_s_slowmatype); - Py_VISIT(traverse_module_state->__pyx_n_s_slowperiod); - Py_VISIT(traverse_module_state->__pyx_n_s_spec); - Py_VISIT(traverse_module_state->__pyx_n_s_startvalue); - Py_VISIT(traverse_module_state->__pyx_n_s_str); - Py_VISIT(traverse_module_state->__pyx_n_s_str2bytes); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ACOS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_AD); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ADD); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ADOSC); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ADX); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ADXR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_APO); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_AROON); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_AROONOSC); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ASIN); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ATAN); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ATR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_AVGPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_BBANDS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_BETA); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_BOP); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CCI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDL2CROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDL3BLACKCROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDL3INSIDE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDL3LINESTRIKE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDL3OUTSIDE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDL3STARSINSOUTH); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDL3WHITESOLDIERS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLABANDONEDBABY); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLADVANCEBLOCK); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLBELTHOLD); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLBREAKAWAY); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLCLOSINGMARUBOZU); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLCONCEALBABYSWALL); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLCOUNTERATTACK); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLDARKCLOUDCOVER); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLDOJISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLDRAGONFLYDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLENGULFING); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLEVENINGDOJISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLEVENINGSTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLGAPSIDESIDEWHITE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLGRAVESTONEDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLHAMMER); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLHANGINGMAN); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLHARAMI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLHARAMICROSS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLHIGHWAVE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLHIKKAKE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLHIKKAKEMOD); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLHOMINGPIGEON); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLIDENTICAL3CROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLINNECK); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLINVERTEDHAMMER); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLKICKING); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLKICKINGBYLENGTH); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLLADDERBOTTOM); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLLONGLEGGEDDOJI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLLONGLINE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLMARUBOZU); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLMATCHINGLOW); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLMATHOLD); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLMORNINGDOJISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLMORNINGSTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLONNECK); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLPIERCING); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLRICKSHAWMAN); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLRISEFALL3METHODS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLSEPARATINGLINES); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLSHOOTINGSTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLSHORTLINE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLSPINNINGTOP); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLSTALLEDPATTERN); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLSTICKSANDWICH); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLTAKURI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLTASUKIGAP); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLTHRUSTING); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLTRISTAR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLUNIQUE3RIVER); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLUPSIDEGAP2CROWS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CDLXSIDEGAP3METHODS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CEIL); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CMO); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_CORREL); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_COS); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_COSH); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_DEMA); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_DIV); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_DX); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_EMA); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_EXP); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_FLOOR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_HT_DCPERIOD); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_HT_DCPHASE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_HT_PHASOR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_HT_SINE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_HT_TRENDLINE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_HT_TRENDMODE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_KAMA); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_LINEARREG); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_LINEARREG_ANGLE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_LINEARREG_INTERCEPT); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_LINEARREG_SLOPE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_LN); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_LOG10); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MA); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MACD); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MACDEXT); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MACDFIX); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MAMA); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MAVP); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MAX); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MAXINDEX); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MEDPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MFI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MIDPOINT); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MIDPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MIN); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MININDEX); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MINMAX); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MINMAXINDEX); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MINUS_DI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MINUS_DM); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MOM); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_MULT); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_NATR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_OBV); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_PLUS_DI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_PLUS_DM); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_PPO); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ROC); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ROCP); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ROCR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ROCR100); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_RSI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_SAR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_SAREXT); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_SIN); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_SINH); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_SMA); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_SQRT); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_STDDEV); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_STOCH); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_STOCHF); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_STOCHRSI); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_SUB); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_SUM); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_T3); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_TAN); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_TANH); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_TEMA); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_TRANGE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_TRIMA); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_TRIX); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_TSF); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_TYPPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_ULTOSC); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_VAR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_WCLPRICE); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_WILLR); - Py_VISIT(traverse_module_state->__pyx_n_s_stream_WMA); - Py_VISIT(traverse_module_state->__pyx_kp_s_stream__s); - Py_VISIT(traverse_module_state->__pyx_n_s_super); - Py_VISIT(traverse_module_state->__pyx_n_s_sys); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_check_success); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_func_unst_ids); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_getFuncInfo); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_getFuncTable); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_getGroupTable); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_getInputParameterInfo); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_getOptInputParameterInfo); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_getOutputParameterInfo); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_get_compatibility); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_get_unstable_period); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_initialize); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_restore_candle_default_setti); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_set_candle_settings); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_set_compatibility); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_set_unstable_period); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_shutdown); - Py_VISIT(traverse_module_state->__pyx_n_s_ta_version); - Py_VISIT(traverse_module_state->__pyx_n_s_table); - Py_VISIT(traverse_module_state->__pyx_kp_s_talib__abstract_pxi); - Py_VISIT(traverse_module_state->__pyx_kp_s_talib__common_pxi); - Py_VISIT(traverse_module_state->__pyx_kp_s_talib__func_pxi); - Py_VISIT(traverse_module_state->__pyx_kp_s_talib__stream_pxi); - Py_VISIT(traverse_module_state->__pyx_n_s_talib__ta_lib); - Py_VISIT(traverse_module_state->__pyx_n_s_test); - Py_VISIT(traverse_module_state->__pyx_n_s_threading); - Py_VISIT(traverse_module_state->__pyx_n_s_timeStamp); - Py_VISIT(traverse_module_state->__pyx_n_s_timeperiod); - Py_VISIT(traverse_module_state->__pyx_n_s_timeperiod1); - Py_VISIT(traverse_module_state->__pyx_n_s_timeperiod2); - Py_VISIT(traverse_module_state->__pyx_n_s_timeperiod3); - Py_VISIT(traverse_module_state->__pyx_n_s_to_numpy); - Py_VISIT(traverse_module_state->__pyx_n_s_type); - Py_VISIT(traverse_module_state->__pyx_n_s_type_2); - Py_VISIT(traverse_module_state->__pyx_n_s_unicode); - Py_VISIT(traverse_module_state->__pyx_n_s_update); - Py_VISIT(traverse_module_state->__pyx_n_s_update_info); - Py_VISIT(traverse_module_state->__pyx_n_s_upper); - Py_VISIT(traverse_module_state->__pyx_n_s_value); - Py_VISIT(traverse_module_state->__pyx_n_s_value_range); - Py_VISIT(traverse_module_state->__pyx_n_s_values); - Py_VISIT(traverse_module_state->__pyx_n_s_version); - Py_VISIT(traverse_module_state->__pyx_n_s_vfactor); - Py_VISIT(traverse_module_state->__pyx_n_s_volume); - Py_VISIT(traverse_module_state->__pyx_n_s_volume_data); - Py_VISIT(traverse_module_state->__pyx_n_s_xrange); - Py_VISIT(traverse_module_state->__pyx_int_0); - Py_VISIT(traverse_module_state->__pyx_int_1); - Py_VISIT(traverse_module_state->__pyx_int_2); - Py_VISIT(traverse_module_state->__pyx_int_3); - Py_VISIT(traverse_module_state->__pyx_int_4); - Py_VISIT(traverse_module_state->__pyx_int_8); - Py_VISIT(traverse_module_state->__pyx_int_9); - Py_VISIT(traverse_module_state->__pyx_int_12); - Py_VISIT(traverse_module_state->__pyx_int_16); - Py_VISIT(traverse_module_state->__pyx_int_32); - Py_VISIT(traverse_module_state->__pyx_int_64); - Py_VISIT(traverse_module_state->__pyx_int_128); - Py_VISIT(traverse_module_state->__pyx_int_256); - Py_VISIT(traverse_module_state->__pyx_int_512); - Py_VISIT(traverse_module_state->__pyx_int_1024); - Py_VISIT(traverse_module_state->__pyx_int_2048); - Py_VISIT(traverse_module_state->__pyx_int_4096); - Py_VISIT(traverse_module_state->__pyx_int_16777216); - Py_VISIT(traverse_module_state->__pyx_int_67108864); - Py_VISIT(traverse_module_state->__pyx_int_134217728); - Py_VISIT(traverse_module_state->__pyx_int_268435456); - Py_VISIT(traverse_module_state->__pyx_int_neg_1); - Py_VISIT(traverse_module_state->__pyx_tuple_); - Py_VISIT(traverse_module_state->__pyx_tuple__2); - Py_VISIT(traverse_module_state->__pyx_tuple__3); - Py_VISIT(traverse_module_state->__pyx_tuple__4); - Py_VISIT(traverse_module_state->__pyx_tuple__5); - Py_VISIT(traverse_module_state->__pyx_tuple__8); - Py_VISIT(traverse_module_state->__pyx_tuple__13); - Py_VISIT(traverse_module_state->__pyx_tuple__15); - Py_VISIT(traverse_module_state->__pyx_tuple__18); - Py_VISIT(traverse_module_state->__pyx_tuple__19); - Py_VISIT(traverse_module_state->__pyx_tuple__20); - Py_VISIT(traverse_module_state->__pyx_tuple__21); - Py_VISIT(traverse_module_state->__pyx_tuple__23); - Py_VISIT(traverse_module_state->__pyx_tuple__25); - Py_VISIT(traverse_module_state->__pyx_tuple__27); - Py_VISIT(traverse_module_state->__pyx_tuple__29); - Py_VISIT(traverse_module_state->__pyx_tuple__31); - Py_VISIT(traverse_module_state->__pyx_tuple__33); - Py_VISIT(traverse_module_state->__pyx_tuple__34); - Py_VISIT(traverse_module_state->__pyx_tuple__35); - Py_VISIT(traverse_module_state->__pyx_tuple__36); - Py_VISIT(traverse_module_state->__pyx_tuple__37); - Py_VISIT(traverse_module_state->__pyx_tuple__38); - Py_VISIT(traverse_module_state->__pyx_tuple__39); - Py_VISIT(traverse_module_state->__pyx_tuple__41); - Py_VISIT(traverse_module_state->__pyx_tuple__44); - Py_VISIT(traverse_module_state->__pyx_tuple__46); - Py_VISIT(traverse_module_state->__pyx_tuple__48); - Py_VISIT(traverse_module_state->__pyx_tuple__50); - Py_VISIT(traverse_module_state->__pyx_tuple__52); - Py_VISIT(traverse_module_state->__pyx_tuple__55); - Py_VISIT(traverse_module_state->__pyx_tuple__57); - Py_VISIT(traverse_module_state->__pyx_tuple__59); - Py_VISIT(traverse_module_state->__pyx_tuple__64); - Py_VISIT(traverse_module_state->__pyx_tuple__66); - Py_VISIT(traverse_module_state->__pyx_tuple__68); - Py_VISIT(traverse_module_state->__pyx_tuple__72); - Py_VISIT(traverse_module_state->__pyx_tuple__80); - Py_VISIT(traverse_module_state->__pyx_tuple__136); - Py_VISIT(traverse_module_state->__pyx_tuple__149); - Py_VISIT(traverse_module_state->__pyx_tuple__151); - Py_VISIT(traverse_module_state->__pyx_tuple__154); - Py_VISIT(traverse_module_state->__pyx_tuple__163); - Py_VISIT(traverse_module_state->__pyx_tuple__165); - Py_VISIT(traverse_module_state->__pyx_tuple__167); - Py_VISIT(traverse_module_state->__pyx_tuple__169); - Py_VISIT(traverse_module_state->__pyx_tuple__171); - Py_VISIT(traverse_module_state->__pyx_tuple__173); - Py_VISIT(traverse_module_state->__pyx_tuple__176); - Py_VISIT(traverse_module_state->__pyx_tuple__178); - Py_VISIT(traverse_module_state->__pyx_tuple__180); - Py_VISIT(traverse_module_state->__pyx_tuple__186); - Py_VISIT(traverse_module_state->__pyx_tuple__188); - Py_VISIT(traverse_module_state->__pyx_tuple__195); - Py_VISIT(traverse_module_state->__pyx_tuple__205); - Py_VISIT(traverse_module_state->__pyx_tuple__207); - Py_VISIT(traverse_module_state->__pyx_tuple__213); - Py_VISIT(traverse_module_state->__pyx_tuple__215); - Py_VISIT(traverse_module_state->__pyx_tuple__217); - Py_VISIT(traverse_module_state->__pyx_tuple__219); - Py_VISIT(traverse_module_state->__pyx_tuple__223); - Py_VISIT(traverse_module_state->__pyx_tuple__228); - Py_VISIT(traverse_module_state->__pyx_tuple__234); - Py_VISIT(traverse_module_state->__pyx_tuple__241); - Py_VISIT(traverse_module_state->__pyx_tuple__243); - Py_VISIT(traverse_module_state->__pyx_tuple__247); - Py_VISIT(traverse_module_state->__pyx_tuple__248); - Py_VISIT(traverse_module_state->__pyx_tuple__249); - Py_VISIT(traverse_module_state->__pyx_tuple__251); - Py_VISIT(traverse_module_state->__pyx_tuple__256); - Py_VISIT(traverse_module_state->__pyx_tuple__258); - Py_VISIT(traverse_module_state->__pyx_tuple__260); - Py_VISIT(traverse_module_state->__pyx_tuple__262); - Py_VISIT(traverse_module_state->__pyx_tuple__264); - Py_VISIT(traverse_module_state->__pyx_tuple__266); - Py_VISIT(traverse_module_state->__pyx_tuple__268); - Py_VISIT(traverse_module_state->__pyx_tuple__269); - Py_VISIT(traverse_module_state->__pyx_tuple__271); - Py_VISIT(traverse_module_state->__pyx_tuple__273); - Py_VISIT(traverse_module_state->__pyx_tuple__275); - Py_VISIT(traverse_module_state->__pyx_tuple__277); - Py_VISIT(traverse_module_state->__pyx_tuple__279); - Py_VISIT(traverse_module_state->__pyx_tuple__281); - Py_VISIT(traverse_module_state->__pyx_tuple__283); - Py_VISIT(traverse_module_state->__pyx_tuple__285); - Py_VISIT(traverse_module_state->__pyx_tuple__287); - Py_VISIT(traverse_module_state->__pyx_tuple__292); - Py_VISIT(traverse_module_state->__pyx_tuple__294); - Py_VISIT(traverse_module_state->__pyx_tuple__296); - Py_VISIT(traverse_module_state->__pyx_tuple__298); - Py_VISIT(traverse_module_state->__pyx_tuple__300); - Py_VISIT(traverse_module_state->__pyx_tuple__302); - Py_VISIT(traverse_module_state->__pyx_tuple__305); - Py_VISIT(traverse_module_state->__pyx_tuple__307); - Py_VISIT(traverse_module_state->__pyx_tuple__309); - Py_VISIT(traverse_module_state->__pyx_tuple__311); - Py_VISIT(traverse_module_state->__pyx_tuple__313); - Py_VISIT(traverse_module_state->__pyx_tuple__315); - Py_VISIT(traverse_module_state->__pyx_tuple__318); - Py_VISIT(traverse_module_state->__pyx_tuple__320); - Py_VISIT(traverse_module_state->__pyx_tuple__322); - Py_VISIT(traverse_module_state->__pyx_tuple__327); - Py_VISIT(traverse_module_state->__pyx_tuple__329); - Py_VISIT(traverse_module_state->__pyx_tuple__331); - Py_VISIT(traverse_module_state->__pyx_tuple__335); - Py_VISIT(traverse_module_state->__pyx_tuple__343); - Py_VISIT(traverse_module_state->__pyx_tuple__399); - Py_VISIT(traverse_module_state->__pyx_tuple__412); - Py_VISIT(traverse_module_state->__pyx_tuple__414); - Py_VISIT(traverse_module_state->__pyx_tuple__417); - Py_VISIT(traverse_module_state->__pyx_tuple__426); - Py_VISIT(traverse_module_state->__pyx_tuple__428); - Py_VISIT(traverse_module_state->__pyx_tuple__430); - Py_VISIT(traverse_module_state->__pyx_tuple__432); - Py_VISIT(traverse_module_state->__pyx_tuple__434); - Py_VISIT(traverse_module_state->__pyx_tuple__436); - Py_VISIT(traverse_module_state->__pyx_tuple__439); - Py_VISIT(traverse_module_state->__pyx_tuple__441); - Py_VISIT(traverse_module_state->__pyx_tuple__443); - Py_VISIT(traverse_module_state->__pyx_tuple__449); - Py_VISIT(traverse_module_state->__pyx_tuple__451); - Py_VISIT(traverse_module_state->__pyx_tuple__458); - Py_VISIT(traverse_module_state->__pyx_tuple__468); - Py_VISIT(traverse_module_state->__pyx_tuple__470); - Py_VISIT(traverse_module_state->__pyx_tuple__476); - Py_VISIT(traverse_module_state->__pyx_tuple__478); - Py_VISIT(traverse_module_state->__pyx_tuple__480); - Py_VISIT(traverse_module_state->__pyx_tuple__482); - Py_VISIT(traverse_module_state->__pyx_tuple__486); - Py_VISIT(traverse_module_state->__pyx_tuple__491); - Py_VISIT(traverse_module_state->__pyx_tuple__497); - Py_VISIT(traverse_module_state->__pyx_codeobj__14); - Py_VISIT(traverse_module_state->__pyx_codeobj__16); - Py_VISIT(traverse_module_state->__pyx_codeobj__17); - Py_VISIT(traverse_module_state->__pyx_codeobj__22); - Py_VISIT(traverse_module_state->__pyx_codeobj__24); - Py_VISIT(traverse_module_state->__pyx_codeobj__26); - Py_VISIT(traverse_module_state->__pyx_codeobj__28); - Py_VISIT(traverse_module_state->__pyx_codeobj__30); - Py_VISIT(traverse_module_state->__pyx_codeobj__32); - Py_VISIT(traverse_module_state->__pyx_codeobj__40); - Py_VISIT(traverse_module_state->__pyx_codeobj__42); - Py_VISIT(traverse_module_state->__pyx_codeobj__45); - Py_VISIT(traverse_module_state->__pyx_codeobj__47); - Py_VISIT(traverse_module_state->__pyx_codeobj__49); - Py_VISIT(traverse_module_state->__pyx_codeobj__51); - Py_VISIT(traverse_module_state->__pyx_codeobj__53); - Py_VISIT(traverse_module_state->__pyx_codeobj__54); - Py_VISIT(traverse_module_state->__pyx_codeobj__56); - Py_VISIT(traverse_module_state->__pyx_codeobj__58); - Py_VISIT(traverse_module_state->__pyx_codeobj__60); - Py_VISIT(traverse_module_state->__pyx_codeobj__61); - Py_VISIT(traverse_module_state->__pyx_codeobj__62); - Py_VISIT(traverse_module_state->__pyx_codeobj__63); - Py_VISIT(traverse_module_state->__pyx_codeobj__65); - Py_VISIT(traverse_module_state->__pyx_codeobj__67); - Py_VISIT(traverse_module_state->__pyx_codeobj__69); - Py_VISIT(traverse_module_state->__pyx_codeobj__70); - Py_VISIT(traverse_module_state->__pyx_codeobj__71); - Py_VISIT(traverse_module_state->__pyx_codeobj__73); - Py_VISIT(traverse_module_state->__pyx_codeobj__74); - Py_VISIT(traverse_module_state->__pyx_codeobj__75); - Py_VISIT(traverse_module_state->__pyx_codeobj__76); - Py_VISIT(traverse_module_state->__pyx_codeobj__77); - Py_VISIT(traverse_module_state->__pyx_codeobj__78); - Py_VISIT(traverse_module_state->__pyx_codeobj__79); - Py_VISIT(traverse_module_state->__pyx_codeobj__81); - Py_VISIT(traverse_module_state->__pyx_codeobj__82); - Py_VISIT(traverse_module_state->__pyx_codeobj__83); - Py_VISIT(traverse_module_state->__pyx_codeobj__84); - Py_VISIT(traverse_module_state->__pyx_codeobj__85); - Py_VISIT(traverse_module_state->__pyx_codeobj__86); - Py_VISIT(traverse_module_state->__pyx_codeobj__87); - Py_VISIT(traverse_module_state->__pyx_codeobj__88); - Py_VISIT(traverse_module_state->__pyx_codeobj__89); - Py_VISIT(traverse_module_state->__pyx_codeobj__90); - Py_VISIT(traverse_module_state->__pyx_codeobj__91); - Py_VISIT(traverse_module_state->__pyx_codeobj__92); - Py_VISIT(traverse_module_state->__pyx_codeobj__93); - Py_VISIT(traverse_module_state->__pyx_codeobj__94); - Py_VISIT(traverse_module_state->__pyx_codeobj__95); - Py_VISIT(traverse_module_state->__pyx_codeobj__96); - Py_VISIT(traverse_module_state->__pyx_codeobj__97); - Py_VISIT(traverse_module_state->__pyx_codeobj__98); - Py_VISIT(traverse_module_state->__pyx_codeobj__99); - Py_VISIT(traverse_module_state->__pyx_codeobj__100); - Py_VISIT(traverse_module_state->__pyx_codeobj__101); - Py_VISIT(traverse_module_state->__pyx_codeobj__102); - Py_VISIT(traverse_module_state->__pyx_codeobj__103); - Py_VISIT(traverse_module_state->__pyx_codeobj__104); - Py_VISIT(traverse_module_state->__pyx_codeobj__105); - Py_VISIT(traverse_module_state->__pyx_codeobj__106); - Py_VISIT(traverse_module_state->__pyx_codeobj__107); - Py_VISIT(traverse_module_state->__pyx_codeobj__108); - Py_VISIT(traverse_module_state->__pyx_codeobj__109); - Py_VISIT(traverse_module_state->__pyx_codeobj__110); - Py_VISIT(traverse_module_state->__pyx_codeobj__111); - Py_VISIT(traverse_module_state->__pyx_codeobj__112); - Py_VISIT(traverse_module_state->__pyx_codeobj__113); - Py_VISIT(traverse_module_state->__pyx_codeobj__114); - Py_VISIT(traverse_module_state->__pyx_codeobj__115); - Py_VISIT(traverse_module_state->__pyx_codeobj__116); - Py_VISIT(traverse_module_state->__pyx_codeobj__117); - Py_VISIT(traverse_module_state->__pyx_codeobj__118); - Py_VISIT(traverse_module_state->__pyx_codeobj__119); - Py_VISIT(traverse_module_state->__pyx_codeobj__120); - Py_VISIT(traverse_module_state->__pyx_codeobj__121); - Py_VISIT(traverse_module_state->__pyx_codeobj__122); - Py_VISIT(traverse_module_state->__pyx_codeobj__123); - Py_VISIT(traverse_module_state->__pyx_codeobj__124); - Py_VISIT(traverse_module_state->__pyx_codeobj__125); - Py_VISIT(traverse_module_state->__pyx_codeobj__126); - Py_VISIT(traverse_module_state->__pyx_codeobj__127); - Py_VISIT(traverse_module_state->__pyx_codeobj__128); - Py_VISIT(traverse_module_state->__pyx_codeobj__129); - Py_VISIT(traverse_module_state->__pyx_codeobj__130); - Py_VISIT(traverse_module_state->__pyx_codeobj__131); - Py_VISIT(traverse_module_state->__pyx_codeobj__132); - Py_VISIT(traverse_module_state->__pyx_codeobj__133); - Py_VISIT(traverse_module_state->__pyx_codeobj__134); - Py_VISIT(traverse_module_state->__pyx_codeobj__135); - Py_VISIT(traverse_module_state->__pyx_codeobj__137); - Py_VISIT(traverse_module_state->__pyx_codeobj__138); - Py_VISIT(traverse_module_state->__pyx_codeobj__139); - Py_VISIT(traverse_module_state->__pyx_codeobj__140); - Py_VISIT(traverse_module_state->__pyx_codeobj__141); - Py_VISIT(traverse_module_state->__pyx_codeobj__142); - Py_VISIT(traverse_module_state->__pyx_codeobj__143); - Py_VISIT(traverse_module_state->__pyx_codeobj__144); - Py_VISIT(traverse_module_state->__pyx_codeobj__145); - Py_VISIT(traverse_module_state->__pyx_codeobj__146); - Py_VISIT(traverse_module_state->__pyx_codeobj__147); - Py_VISIT(traverse_module_state->__pyx_codeobj__148); - Py_VISIT(traverse_module_state->__pyx_codeobj__150); - Py_VISIT(traverse_module_state->__pyx_codeobj__152); - Py_VISIT(traverse_module_state->__pyx_codeobj__153); - Py_VISIT(traverse_module_state->__pyx_codeobj__155); - Py_VISIT(traverse_module_state->__pyx_codeobj__156); - Py_VISIT(traverse_module_state->__pyx_codeobj__157); - Py_VISIT(traverse_module_state->__pyx_codeobj__158); - Py_VISIT(traverse_module_state->__pyx_codeobj__159); - Py_VISIT(traverse_module_state->__pyx_codeobj__160); - Py_VISIT(traverse_module_state->__pyx_codeobj__161); - Py_VISIT(traverse_module_state->__pyx_codeobj__162); - Py_VISIT(traverse_module_state->__pyx_codeobj__164); - Py_VISIT(traverse_module_state->__pyx_codeobj__166); - Py_VISIT(traverse_module_state->__pyx_codeobj__168); - Py_VISIT(traverse_module_state->__pyx_codeobj__170); - Py_VISIT(traverse_module_state->__pyx_codeobj__172); - Py_VISIT(traverse_module_state->__pyx_codeobj__174); - Py_VISIT(traverse_module_state->__pyx_codeobj__175); - Py_VISIT(traverse_module_state->__pyx_codeobj__177); - Py_VISIT(traverse_module_state->__pyx_codeobj__179); - Py_VISIT(traverse_module_state->__pyx_codeobj__181); - Py_VISIT(traverse_module_state->__pyx_codeobj__182); - Py_VISIT(traverse_module_state->__pyx_codeobj__183); - Py_VISIT(traverse_module_state->__pyx_codeobj__184); - Py_VISIT(traverse_module_state->__pyx_codeobj__185); - Py_VISIT(traverse_module_state->__pyx_codeobj__187); - Py_VISIT(traverse_module_state->__pyx_codeobj__189); - Py_VISIT(traverse_module_state->__pyx_codeobj__190); - Py_VISIT(traverse_module_state->__pyx_codeobj__191); - Py_VISIT(traverse_module_state->__pyx_codeobj__192); - Py_VISIT(traverse_module_state->__pyx_codeobj__193); - Py_VISIT(traverse_module_state->__pyx_codeobj__194); - Py_VISIT(traverse_module_state->__pyx_codeobj__196); - Py_VISIT(traverse_module_state->__pyx_codeobj__197); - Py_VISIT(traverse_module_state->__pyx_codeobj__198); - Py_VISIT(traverse_module_state->__pyx_codeobj__199); - Py_VISIT(traverse_module_state->__pyx_codeobj__200); - Py_VISIT(traverse_module_state->__pyx_codeobj__201); - Py_VISIT(traverse_module_state->__pyx_codeobj__202); - Py_VISIT(traverse_module_state->__pyx_codeobj__203); - Py_VISIT(traverse_module_state->__pyx_codeobj__204); - Py_VISIT(traverse_module_state->__pyx_codeobj__206); - Py_VISIT(traverse_module_state->__pyx_codeobj__208); - Py_VISIT(traverse_module_state->__pyx_codeobj__209); - Py_VISIT(traverse_module_state->__pyx_codeobj__210); - Py_VISIT(traverse_module_state->__pyx_codeobj__211); - Py_VISIT(traverse_module_state->__pyx_codeobj__212); - Py_VISIT(traverse_module_state->__pyx_codeobj__214); - Py_VISIT(traverse_module_state->__pyx_codeobj__216); - Py_VISIT(traverse_module_state->__pyx_codeobj__218); - Py_VISIT(traverse_module_state->__pyx_codeobj__220); - Py_VISIT(traverse_module_state->__pyx_codeobj__221); - Py_VISIT(traverse_module_state->__pyx_codeobj__222); - Py_VISIT(traverse_module_state->__pyx_codeobj__224); - Py_VISIT(traverse_module_state->__pyx_codeobj__225); - Py_VISIT(traverse_module_state->__pyx_codeobj__226); - Py_VISIT(traverse_module_state->__pyx_codeobj__227); - Py_VISIT(traverse_module_state->__pyx_codeobj__229); - Py_VISIT(traverse_module_state->__pyx_codeobj__230); - Py_VISIT(traverse_module_state->__pyx_codeobj__231); - Py_VISIT(traverse_module_state->__pyx_codeobj__232); - Py_VISIT(traverse_module_state->__pyx_codeobj__233); - Py_VISIT(traverse_module_state->__pyx_codeobj__235); - Py_VISIT(traverse_module_state->__pyx_codeobj__236); - Py_VISIT(traverse_module_state->__pyx_codeobj__237); - Py_VISIT(traverse_module_state->__pyx_codeobj__238); - Py_VISIT(traverse_module_state->__pyx_codeobj__239); - Py_VISIT(traverse_module_state->__pyx_codeobj__242); - Py_VISIT(traverse_module_state->__pyx_codeobj__244); - Py_VISIT(traverse_module_state->__pyx_codeobj__245); - Py_VISIT(traverse_module_state->__pyx_codeobj__246); - Py_VISIT(traverse_module_state->__pyx_codeobj__250); - Py_VISIT(traverse_module_state->__pyx_codeobj__252); - Py_VISIT(traverse_module_state->__pyx_codeobj__253); - Py_VISIT(traverse_module_state->__pyx_codeobj__254); - Py_VISIT(traverse_module_state->__pyx_codeobj__255); - Py_VISIT(traverse_module_state->__pyx_codeobj__257); - Py_VISIT(traverse_module_state->__pyx_codeobj__259); - Py_VISIT(traverse_module_state->__pyx_codeobj__261); - Py_VISIT(traverse_module_state->__pyx_codeobj__263); - Py_VISIT(traverse_module_state->__pyx_codeobj__265); - Py_VISIT(traverse_module_state->__pyx_codeobj__267); - Py_VISIT(traverse_module_state->__pyx_codeobj__270); - Py_VISIT(traverse_module_state->__pyx_codeobj__272); - Py_VISIT(traverse_module_state->__pyx_codeobj__274); - Py_VISIT(traverse_module_state->__pyx_codeobj__276); - Py_VISIT(traverse_module_state->__pyx_codeobj__278); - Py_VISIT(traverse_module_state->__pyx_codeobj__280); - Py_VISIT(traverse_module_state->__pyx_codeobj__282); - Py_VISIT(traverse_module_state->__pyx_codeobj__284); - Py_VISIT(traverse_module_state->__pyx_codeobj__286); - Py_VISIT(traverse_module_state->__pyx_codeobj__288); - Py_VISIT(traverse_module_state->__pyx_codeobj__289); - Py_VISIT(traverse_module_state->__pyx_codeobj__290); - Py_VISIT(traverse_module_state->__pyx_codeobj__291); - Py_VISIT(traverse_module_state->__pyx_codeobj__293); - Py_VISIT(traverse_module_state->__pyx_codeobj__295); - Py_VISIT(traverse_module_state->__pyx_codeobj__297); - Py_VISIT(traverse_module_state->__pyx_codeobj__299); - Py_VISIT(traverse_module_state->__pyx_codeobj__301); - Py_VISIT(traverse_module_state->__pyx_codeobj__303); - Py_VISIT(traverse_module_state->__pyx_codeobj__304); - Py_VISIT(traverse_module_state->__pyx_codeobj__306); - Py_VISIT(traverse_module_state->__pyx_codeobj__308); - Py_VISIT(traverse_module_state->__pyx_codeobj__310); - Py_VISIT(traverse_module_state->__pyx_codeobj__312); - Py_VISIT(traverse_module_state->__pyx_codeobj__314); - Py_VISIT(traverse_module_state->__pyx_codeobj__316); - Py_VISIT(traverse_module_state->__pyx_codeobj__317); - Py_VISIT(traverse_module_state->__pyx_codeobj__319); - Py_VISIT(traverse_module_state->__pyx_codeobj__321); - Py_VISIT(traverse_module_state->__pyx_codeobj__323); - Py_VISIT(traverse_module_state->__pyx_codeobj__324); - Py_VISIT(traverse_module_state->__pyx_codeobj__325); - Py_VISIT(traverse_module_state->__pyx_codeobj__326); - Py_VISIT(traverse_module_state->__pyx_codeobj__328); - Py_VISIT(traverse_module_state->__pyx_codeobj__330); - Py_VISIT(traverse_module_state->__pyx_codeobj__332); - Py_VISIT(traverse_module_state->__pyx_codeobj__333); - Py_VISIT(traverse_module_state->__pyx_codeobj__334); - Py_VISIT(traverse_module_state->__pyx_codeobj__336); - Py_VISIT(traverse_module_state->__pyx_codeobj__337); - Py_VISIT(traverse_module_state->__pyx_codeobj__338); - Py_VISIT(traverse_module_state->__pyx_codeobj__339); - Py_VISIT(traverse_module_state->__pyx_codeobj__340); - Py_VISIT(traverse_module_state->__pyx_codeobj__341); - Py_VISIT(traverse_module_state->__pyx_codeobj__342); - Py_VISIT(traverse_module_state->__pyx_codeobj__344); - Py_VISIT(traverse_module_state->__pyx_codeobj__345); - Py_VISIT(traverse_module_state->__pyx_codeobj__346); - Py_VISIT(traverse_module_state->__pyx_codeobj__347); - Py_VISIT(traverse_module_state->__pyx_codeobj__348); - Py_VISIT(traverse_module_state->__pyx_codeobj__349); - Py_VISIT(traverse_module_state->__pyx_codeobj__350); - Py_VISIT(traverse_module_state->__pyx_codeobj__351); - Py_VISIT(traverse_module_state->__pyx_codeobj__352); - Py_VISIT(traverse_module_state->__pyx_codeobj__353); - Py_VISIT(traverse_module_state->__pyx_codeobj__354); - Py_VISIT(traverse_module_state->__pyx_codeobj__355); - Py_VISIT(traverse_module_state->__pyx_codeobj__356); - Py_VISIT(traverse_module_state->__pyx_codeobj__357); - Py_VISIT(traverse_module_state->__pyx_codeobj__358); - Py_VISIT(traverse_module_state->__pyx_codeobj__359); - Py_VISIT(traverse_module_state->__pyx_codeobj__360); - Py_VISIT(traverse_module_state->__pyx_codeobj__361); - Py_VISIT(traverse_module_state->__pyx_codeobj__362); - Py_VISIT(traverse_module_state->__pyx_codeobj__363); - Py_VISIT(traverse_module_state->__pyx_codeobj__364); - Py_VISIT(traverse_module_state->__pyx_codeobj__365); - Py_VISIT(traverse_module_state->__pyx_codeobj__366); - Py_VISIT(traverse_module_state->__pyx_codeobj__367); - Py_VISIT(traverse_module_state->__pyx_codeobj__368); - Py_VISIT(traverse_module_state->__pyx_codeobj__369); - Py_VISIT(traverse_module_state->__pyx_codeobj__370); - Py_VISIT(traverse_module_state->__pyx_codeobj__371); - Py_VISIT(traverse_module_state->__pyx_codeobj__372); - Py_VISIT(traverse_module_state->__pyx_codeobj__373); - Py_VISIT(traverse_module_state->__pyx_codeobj__374); - Py_VISIT(traverse_module_state->__pyx_codeobj__375); - Py_VISIT(traverse_module_state->__pyx_codeobj__376); - Py_VISIT(traverse_module_state->__pyx_codeobj__377); - Py_VISIT(traverse_module_state->__pyx_codeobj__378); - Py_VISIT(traverse_module_state->__pyx_codeobj__379); - Py_VISIT(traverse_module_state->__pyx_codeobj__380); - Py_VISIT(traverse_module_state->__pyx_codeobj__381); - Py_VISIT(traverse_module_state->__pyx_codeobj__382); - Py_VISIT(traverse_module_state->__pyx_codeobj__383); - Py_VISIT(traverse_module_state->__pyx_codeobj__384); - Py_VISIT(traverse_module_state->__pyx_codeobj__385); - Py_VISIT(traverse_module_state->__pyx_codeobj__386); - Py_VISIT(traverse_module_state->__pyx_codeobj__387); - Py_VISIT(traverse_module_state->__pyx_codeobj__388); - Py_VISIT(traverse_module_state->__pyx_codeobj__389); - Py_VISIT(traverse_module_state->__pyx_codeobj__390); - Py_VISIT(traverse_module_state->__pyx_codeobj__391); - Py_VISIT(traverse_module_state->__pyx_codeobj__392); - Py_VISIT(traverse_module_state->__pyx_codeobj__393); - Py_VISIT(traverse_module_state->__pyx_codeobj__394); - Py_VISIT(traverse_module_state->__pyx_codeobj__395); - Py_VISIT(traverse_module_state->__pyx_codeobj__396); - Py_VISIT(traverse_module_state->__pyx_codeobj__397); - Py_VISIT(traverse_module_state->__pyx_codeobj__398); - Py_VISIT(traverse_module_state->__pyx_codeobj__400); - Py_VISIT(traverse_module_state->__pyx_codeobj__401); - Py_VISIT(traverse_module_state->__pyx_codeobj__402); - Py_VISIT(traverse_module_state->__pyx_codeobj__403); - Py_VISIT(traverse_module_state->__pyx_codeobj__404); - Py_VISIT(traverse_module_state->__pyx_codeobj__405); - Py_VISIT(traverse_module_state->__pyx_codeobj__406); - Py_VISIT(traverse_module_state->__pyx_codeobj__407); - Py_VISIT(traverse_module_state->__pyx_codeobj__408); - Py_VISIT(traverse_module_state->__pyx_codeobj__409); - Py_VISIT(traverse_module_state->__pyx_codeobj__410); - Py_VISIT(traverse_module_state->__pyx_codeobj__411); - Py_VISIT(traverse_module_state->__pyx_codeobj__413); - Py_VISIT(traverse_module_state->__pyx_codeobj__415); - Py_VISIT(traverse_module_state->__pyx_codeobj__416); - Py_VISIT(traverse_module_state->__pyx_codeobj__418); - Py_VISIT(traverse_module_state->__pyx_codeobj__419); - Py_VISIT(traverse_module_state->__pyx_codeobj__420); - Py_VISIT(traverse_module_state->__pyx_codeobj__421); - Py_VISIT(traverse_module_state->__pyx_codeobj__422); - Py_VISIT(traverse_module_state->__pyx_codeobj__423); - Py_VISIT(traverse_module_state->__pyx_codeobj__424); - Py_VISIT(traverse_module_state->__pyx_codeobj__425); - Py_VISIT(traverse_module_state->__pyx_codeobj__427); - Py_VISIT(traverse_module_state->__pyx_codeobj__429); - Py_VISIT(traverse_module_state->__pyx_codeobj__431); - Py_VISIT(traverse_module_state->__pyx_codeobj__433); - Py_VISIT(traverse_module_state->__pyx_codeobj__435); - Py_VISIT(traverse_module_state->__pyx_codeobj__437); - Py_VISIT(traverse_module_state->__pyx_codeobj__438); - Py_VISIT(traverse_module_state->__pyx_codeobj__440); - Py_VISIT(traverse_module_state->__pyx_codeobj__442); - Py_VISIT(traverse_module_state->__pyx_codeobj__444); - Py_VISIT(traverse_module_state->__pyx_codeobj__445); - Py_VISIT(traverse_module_state->__pyx_codeobj__446); - Py_VISIT(traverse_module_state->__pyx_codeobj__447); - Py_VISIT(traverse_module_state->__pyx_codeobj__448); - Py_VISIT(traverse_module_state->__pyx_codeobj__450); - Py_VISIT(traverse_module_state->__pyx_codeobj__452); - Py_VISIT(traverse_module_state->__pyx_codeobj__453); - Py_VISIT(traverse_module_state->__pyx_codeobj__454); - Py_VISIT(traverse_module_state->__pyx_codeobj__455); - Py_VISIT(traverse_module_state->__pyx_codeobj__456); - Py_VISIT(traverse_module_state->__pyx_codeobj__457); - Py_VISIT(traverse_module_state->__pyx_codeobj__459); - Py_VISIT(traverse_module_state->__pyx_codeobj__460); - Py_VISIT(traverse_module_state->__pyx_codeobj__461); - Py_VISIT(traverse_module_state->__pyx_codeobj__462); - Py_VISIT(traverse_module_state->__pyx_codeobj__463); - Py_VISIT(traverse_module_state->__pyx_codeobj__464); - Py_VISIT(traverse_module_state->__pyx_codeobj__465); - Py_VISIT(traverse_module_state->__pyx_codeobj__466); - Py_VISIT(traverse_module_state->__pyx_codeobj__467); - Py_VISIT(traverse_module_state->__pyx_codeobj__469); - Py_VISIT(traverse_module_state->__pyx_codeobj__471); - Py_VISIT(traverse_module_state->__pyx_codeobj__472); - Py_VISIT(traverse_module_state->__pyx_codeobj__473); - Py_VISIT(traverse_module_state->__pyx_codeobj__474); - Py_VISIT(traverse_module_state->__pyx_codeobj__475); - Py_VISIT(traverse_module_state->__pyx_codeobj__477); - Py_VISIT(traverse_module_state->__pyx_codeobj__479); - Py_VISIT(traverse_module_state->__pyx_codeobj__481); - Py_VISIT(traverse_module_state->__pyx_codeobj__483); - Py_VISIT(traverse_module_state->__pyx_codeobj__484); - Py_VISIT(traverse_module_state->__pyx_codeobj__485); - Py_VISIT(traverse_module_state->__pyx_codeobj__487); - Py_VISIT(traverse_module_state->__pyx_codeobj__488); - Py_VISIT(traverse_module_state->__pyx_codeobj__489); - Py_VISIT(traverse_module_state->__pyx_codeobj__490); - Py_VISIT(traverse_module_state->__pyx_codeobj__492); - Py_VISIT(traverse_module_state->__pyx_codeobj__493); - Py_VISIT(traverse_module_state->__pyx_codeobj__494); - Py_VISIT(traverse_module_state->__pyx_codeobj__495); - Py_VISIT(traverse_module_state->__pyx_codeobj__496); - Py_VISIT(traverse_module_state->__pyx_codeobj__498); - Py_VISIT(traverse_module_state->__pyx_codeobj__499); - Py_VISIT(traverse_module_state->__pyx_codeobj__500); - Py_VISIT(traverse_module_state->__pyx_codeobj__501); - Py_VISIT(traverse_module_state->__pyx_codeobj__502); - return 0; + 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<1153; ++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_state_defines ### */ -#define __pyx_d __pyx_mstate_global->__pyx_d -#define __pyx_b __pyx_mstate_global->__pyx_b -#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime -#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple -#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes -#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode -#ifdef __Pyx_CyFunction_USED -#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType -#endif -#ifdef __Pyx_FusedFunction_USED -#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType -#endif -#ifdef __Pyx_Generator_USED -#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType -#endif -#ifdef __Pyx_IterableCoroutine_USED -#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#define __pyx_ptype_5numpy_dtype __pyx_mstate_global->__pyx_ptype_5numpy_dtype -#define __pyx_ptype_5numpy_flatiter __pyx_mstate_global->__pyx_ptype_5numpy_flatiter -#define __pyx_ptype_5numpy_broadcast __pyx_mstate_global->__pyx_ptype_5numpy_broadcast -#define __pyx_ptype_5numpy_ndarray __pyx_mstate_global->__pyx_ptype_5numpy_ndarray -#define __pyx_ptype_5numpy_generic __pyx_mstate_global->__pyx_ptype_5numpy_generic -#define __pyx_ptype_5numpy_number __pyx_mstate_global->__pyx_ptype_5numpy_number -#define __pyx_ptype_5numpy_integer __pyx_mstate_global->__pyx_ptype_5numpy_integer -#define __pyx_ptype_5numpy_signedinteger __pyx_mstate_global->__pyx_ptype_5numpy_signedinteger -#define __pyx_ptype_5numpy_unsignedinteger __pyx_mstate_global->__pyx_ptype_5numpy_unsignedinteger -#define __pyx_ptype_5numpy_inexact __pyx_mstate_global->__pyx_ptype_5numpy_inexact -#define __pyx_ptype_5numpy_floating __pyx_mstate_global->__pyx_ptype_5numpy_floating -#define __pyx_ptype_5numpy_complexfloating __pyx_mstate_global->__pyx_ptype_5numpy_complexfloating -#define __pyx_ptype_5numpy_flexible __pyx_mstate_global->__pyx_ptype_5numpy_flexible -#define __pyx_ptype_5numpy_character __pyx_mstate_global->__pyx_ptype_5numpy_character -#define __pyx_ptype_5numpy_ufunc __pyx_mstate_global->__pyx_ptype_5numpy_ufunc -#if CYTHON_USE_MODULE_STATE -#endif -#define __pyx_kp_s_3 __pyx_mstate_global->__pyx_kp_s_3 -#define __pyx_n_s_ACOS __pyx_mstate_global->__pyx_n_s_ACOS -#define __pyx_n_s_AD __pyx_mstate_global->__pyx_n_s_AD -#define __pyx_n_s_ADD __pyx_mstate_global->__pyx_n_s_ADD -#define __pyx_n_s_ADOSC __pyx_mstate_global->__pyx_n_s_ADOSC -#define __pyx_n_s_ADX __pyx_mstate_global->__pyx_n_s_ADX -#define __pyx_n_s_ADXR __pyx_mstate_global->__pyx_n_s_ADXR -#define __pyx_n_s_ALL __pyx_mstate_global->__pyx_n_s_ALL -#define __pyx_n_s_APO __pyx_mstate_global->__pyx_n_s_APO -#define __pyx_n_s_AROON __pyx_mstate_global->__pyx_n_s_AROON -#define __pyx_n_s_AROONOSC __pyx_mstate_global->__pyx_n_s_AROONOSC -#define __pyx_n_s_ARRAY_TYPES __pyx_mstate_global->__pyx_n_s_ARRAY_TYPES -#define __pyx_n_s_ASIN __pyx_mstate_global->__pyx_n_s_ASIN -#define __pyx_n_s_ATAN __pyx_mstate_global->__pyx_n_s_ATAN -#define __pyx_n_s_ATR __pyx_mstate_global->__pyx_n_s_ATR -#define __pyx_n_s_AVGPRICE __pyx_mstate_global->__pyx_n_s_AVGPRICE -#define __pyx_n_s_AllCandleSettings __pyx_mstate_global->__pyx_n_s_AllCandleSettings -#define __pyx_kp_s_Allocation_Error_TA_ALLOC_ERR __pyx_mstate_global->__pyx_kp_s_Allocation_Error_TA_ALLOC_ERR -#define __pyx_n_s_BBANDS __pyx_mstate_global->__pyx_n_s_BBANDS -#define __pyx_n_s_BETA __pyx_mstate_global->__pyx_n_s_BETA -#define __pyx_n_s_BOP __pyx_mstate_global->__pyx_n_s_BOP -#define __pyx_kp_s_Bad_Object_TA_BAD_OBJECT __pyx_mstate_global->__pyx_kp_s_Bad_Object_TA_BAD_OBJECT -#define __pyx_kp_s_Bad_Parameter_TA_BAD_PARAM __pyx_mstate_global->__pyx_kp_s_Bad_Parameter_TA_BAD_PARAM -#define __pyx_n_s_BodyDoji __pyx_mstate_global->__pyx_n_s_BodyDoji -#define __pyx_n_s_BodyLong __pyx_mstate_global->__pyx_n_s_BodyLong -#define __pyx_n_s_BodyShort __pyx_mstate_global->__pyx_n_s_BodyShort -#define __pyx_n_s_BodyVeryLong __pyx_mstate_global->__pyx_n_s_BodyVeryLong -#define __pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut __pyx_mstate_global->__pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut -#define __pyx_n_s_CCI __pyx_mstate_global->__pyx_n_s_CCI -#define __pyx_n_s_CDL2CROWS __pyx_mstate_global->__pyx_n_s_CDL2CROWS -#define __pyx_n_s_CDL3BLACKCROWS __pyx_mstate_global->__pyx_n_s_CDL3BLACKCROWS -#define __pyx_n_s_CDL3INSIDE __pyx_mstate_global->__pyx_n_s_CDL3INSIDE -#define __pyx_n_s_CDL3LINESTRIKE __pyx_mstate_global->__pyx_n_s_CDL3LINESTRIKE -#define __pyx_n_s_CDL3OUTSIDE __pyx_mstate_global->__pyx_n_s_CDL3OUTSIDE -#define __pyx_n_s_CDL3STARSINSOUTH __pyx_mstate_global->__pyx_n_s_CDL3STARSINSOUTH -#define __pyx_n_s_CDL3WHITESOLDIERS __pyx_mstate_global->__pyx_n_s_CDL3WHITESOLDIERS -#define __pyx_n_s_CDLABANDONEDBABY __pyx_mstate_global->__pyx_n_s_CDLABANDONEDBABY -#define __pyx_n_s_CDLADVANCEBLOCK __pyx_mstate_global->__pyx_n_s_CDLADVANCEBLOCK -#define __pyx_n_s_CDLBELTHOLD __pyx_mstate_global->__pyx_n_s_CDLBELTHOLD -#define __pyx_n_s_CDLBREAKAWAY __pyx_mstate_global->__pyx_n_s_CDLBREAKAWAY -#define __pyx_n_s_CDLCLOSINGMARUBOZU __pyx_mstate_global->__pyx_n_s_CDLCLOSINGMARUBOZU -#define __pyx_n_s_CDLCONCEALBABYSWALL __pyx_mstate_global->__pyx_n_s_CDLCONCEALBABYSWALL -#define __pyx_n_s_CDLCOUNTERATTACK __pyx_mstate_global->__pyx_n_s_CDLCOUNTERATTACK -#define __pyx_n_s_CDLDARKCLOUDCOVER __pyx_mstate_global->__pyx_n_s_CDLDARKCLOUDCOVER -#define __pyx_n_s_CDLDOJI __pyx_mstate_global->__pyx_n_s_CDLDOJI -#define __pyx_n_s_CDLDOJISTAR __pyx_mstate_global->__pyx_n_s_CDLDOJISTAR -#define __pyx_n_s_CDLDRAGONFLYDOJI __pyx_mstate_global->__pyx_n_s_CDLDRAGONFLYDOJI -#define __pyx_n_s_CDLENGULFING __pyx_mstate_global->__pyx_n_s_CDLENGULFING -#define __pyx_n_s_CDLEVENINGDOJISTAR __pyx_mstate_global->__pyx_n_s_CDLEVENINGDOJISTAR -#define __pyx_n_s_CDLEVENINGSTAR __pyx_mstate_global->__pyx_n_s_CDLEVENINGSTAR -#define __pyx_n_s_CDLGAPSIDESIDEWHITE __pyx_mstate_global->__pyx_n_s_CDLGAPSIDESIDEWHITE -#define __pyx_n_s_CDLGRAVESTONEDOJI __pyx_mstate_global->__pyx_n_s_CDLGRAVESTONEDOJI -#define __pyx_n_s_CDLHAMMER __pyx_mstate_global->__pyx_n_s_CDLHAMMER -#define __pyx_n_s_CDLHANGINGMAN __pyx_mstate_global->__pyx_n_s_CDLHANGINGMAN -#define __pyx_n_s_CDLHARAMI __pyx_mstate_global->__pyx_n_s_CDLHARAMI -#define __pyx_n_s_CDLHARAMICROSS __pyx_mstate_global->__pyx_n_s_CDLHARAMICROSS -#define __pyx_n_s_CDLHIGHWAVE __pyx_mstate_global->__pyx_n_s_CDLHIGHWAVE -#define __pyx_n_s_CDLHIKKAKE __pyx_mstate_global->__pyx_n_s_CDLHIKKAKE -#define __pyx_n_s_CDLHIKKAKEMOD __pyx_mstate_global->__pyx_n_s_CDLHIKKAKEMOD -#define __pyx_n_s_CDLHOMINGPIGEON __pyx_mstate_global->__pyx_n_s_CDLHOMINGPIGEON -#define __pyx_n_s_CDLIDENTICAL3CROWS __pyx_mstate_global->__pyx_n_s_CDLIDENTICAL3CROWS -#define __pyx_n_s_CDLINNECK __pyx_mstate_global->__pyx_n_s_CDLINNECK -#define __pyx_n_s_CDLINVERTEDHAMMER __pyx_mstate_global->__pyx_n_s_CDLINVERTEDHAMMER -#define __pyx_n_s_CDLKICKING __pyx_mstate_global->__pyx_n_s_CDLKICKING -#define __pyx_n_s_CDLKICKINGBYLENGTH __pyx_mstate_global->__pyx_n_s_CDLKICKINGBYLENGTH -#define __pyx_n_s_CDLLADDERBOTTOM __pyx_mstate_global->__pyx_n_s_CDLLADDERBOTTOM -#define __pyx_n_s_CDLLONGLEGGEDDOJI __pyx_mstate_global->__pyx_n_s_CDLLONGLEGGEDDOJI -#define __pyx_n_s_CDLLONGLINE __pyx_mstate_global->__pyx_n_s_CDLLONGLINE -#define __pyx_n_s_CDLMARUBOZU __pyx_mstate_global->__pyx_n_s_CDLMARUBOZU -#define __pyx_n_s_CDLMATCHINGLOW __pyx_mstate_global->__pyx_n_s_CDLMATCHINGLOW -#define __pyx_n_s_CDLMATHOLD __pyx_mstate_global->__pyx_n_s_CDLMATHOLD -#define __pyx_n_s_CDLMORNINGDOJISTAR __pyx_mstate_global->__pyx_n_s_CDLMORNINGDOJISTAR -#define __pyx_n_s_CDLMORNINGSTAR __pyx_mstate_global->__pyx_n_s_CDLMORNINGSTAR -#define __pyx_n_s_CDLONNECK __pyx_mstate_global->__pyx_n_s_CDLONNECK -#define __pyx_n_s_CDLPIERCING __pyx_mstate_global->__pyx_n_s_CDLPIERCING -#define __pyx_n_s_CDLRICKSHAWMAN __pyx_mstate_global->__pyx_n_s_CDLRICKSHAWMAN -#define __pyx_n_s_CDLRISEFALL3METHODS __pyx_mstate_global->__pyx_n_s_CDLRISEFALL3METHODS -#define __pyx_n_s_CDLSEPARATINGLINES __pyx_mstate_global->__pyx_n_s_CDLSEPARATINGLINES -#define __pyx_n_s_CDLSHOOTINGSTAR __pyx_mstate_global->__pyx_n_s_CDLSHOOTINGSTAR -#define __pyx_n_s_CDLSHORTLINE __pyx_mstate_global->__pyx_n_s_CDLSHORTLINE -#define __pyx_n_s_CDLSPINNINGTOP __pyx_mstate_global->__pyx_n_s_CDLSPINNINGTOP -#define __pyx_n_s_CDLSTALLEDPATTERN __pyx_mstate_global->__pyx_n_s_CDLSTALLEDPATTERN -#define __pyx_n_s_CDLSTICKSANDWICH __pyx_mstate_global->__pyx_n_s_CDLSTICKSANDWICH -#define __pyx_n_s_CDLTAKURI __pyx_mstate_global->__pyx_n_s_CDLTAKURI -#define __pyx_n_s_CDLTASUKIGAP __pyx_mstate_global->__pyx_n_s_CDLTASUKIGAP -#define __pyx_n_s_CDLTHRUSTING __pyx_mstate_global->__pyx_n_s_CDLTHRUSTING -#define __pyx_n_s_CDLTRISTAR __pyx_mstate_global->__pyx_n_s_CDLTRISTAR -#define __pyx_n_s_CDLUNIQUE3RIVER __pyx_mstate_global->__pyx_n_s_CDLUNIQUE3RIVER -#define __pyx_n_s_CDLUPSIDEGAP2CROWS __pyx_mstate_global->__pyx_n_s_CDLUPSIDEGAP2CROWS -#define __pyx_n_s_CDLXSIDEGAP3METHODS __pyx_mstate_global->__pyx_n_s_CDLXSIDEGAP3METHODS -#define __pyx_n_s_CEIL __pyx_mstate_global->__pyx_n_s_CEIL -#define __pyx_n_s_CMO __pyx_mstate_global->__pyx_n_s_CMO -#define __pyx_n_s_CORREL __pyx_mstate_global->__pyx_n_s_CORREL -#define __pyx_n_s_COS __pyx_mstate_global->__pyx_n_s_COS -#define __pyx_n_s_COSH __pyx_mstate_global->__pyx_n_s_COSH -#define __pyx_n_s_CandleSettingType __pyx_mstate_global->__pyx_n_s_CandleSettingType -#define __pyx_n_s_DEMA __pyx_mstate_global->__pyx_n_s_DEMA -#define __pyx_n_s_DIV __pyx_mstate_global->__pyx_n_s_DIV -#define __pyx_n_s_DX __pyx_mstate_global->__pyx_n_s_DX -#define __pyx_kp_s_Dashed_Line __pyx_mstate_global->__pyx_kp_s_Dashed_Line -#define __pyx_n_s_DataFrame __pyx_mstate_global->__pyx_n_s_DataFrame -#define __pyx_n_s_Dot __pyx_mstate_global->__pyx_n_s_Dot -#define __pyx_kp_s_Dotted_Line __pyx_mstate_global->__pyx_kp_s_Dotted_Line -#define __pyx_kp_s_Double_Exponential_Moving_Averag __pyx_mstate_global->__pyx_kp_s_Double_Exponential_Moving_Averag -#define __pyx_n_s_EMA __pyx_mstate_global->__pyx_n_s_EMA -#define __pyx_n_s_EXP __pyx_mstate_global->__pyx_n_s_EXP -#define __pyx_n_s_Equal __pyx_mstate_global->__pyx_n_s_Equal -#define __pyx_kp_s_Exponential_Moving_Average __pyx_mstate_global->__pyx_kp_s_Exponential_Moving_Average -#define __pyx_n_s_FLOOR __pyx_mstate_global->__pyx_n_s_FLOOR -#define __pyx_n_s_Far __pyx_mstate_global->__pyx_n_s_Far -#define __pyx_n_s_Function __pyx_mstate_global->__pyx_n_s_Function -#define __pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F __pyx_mstate_global->__pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F -#define __pyx_n_s_Function___call __pyx_mstate_global->__pyx_n_s_Function___call -#define __pyx_n_s_Function___call_function __pyx_mstate_global->__pyx_n_s_Function___call_function -#define __pyx_n_s_Function___check_opt_input_value __pyx_mstate_global->__pyx_n_s_Function___check_opt_input_value -#define __pyx_n_s_Function___get_opt_input_value __pyx_mstate_global->__pyx_n_s_Function___get_opt_input_value -#define __pyx_n_s_Function___init __pyx_mstate_global->__pyx_n_s_Function___init -#define __pyx_n_s_Function___input_price_series_na __pyx_mstate_global->__pyx_n_s_Function___input_price_series_na -#define __pyx_n_s_Function___local __pyx_mstate_global->__pyx_n_s_Function___local -#define __pyx_n_s_Function___repr __pyx_mstate_global->__pyx_n_s_Function___repr -#define __pyx_n_s_Function___str __pyx_mstate_global->__pyx_n_s_Function___str -#define __pyx_n_s_Function___unicode __pyx_mstate_global->__pyx_n_s_Function___unicode -#define __pyx_n_s_Function__call_function __pyx_mstate_global->__pyx_n_s_Function__call_function -#define __pyx_n_s_Function__check_opt_input_value __pyx_mstate_global->__pyx_n_s_Function__check_opt_input_value -#define __pyx_n_s_Function__get_opt_input_value __pyx_mstate_global->__pyx_n_s_Function__get_opt_input_value -#define __pyx_n_s_Function__input_price_series_na __pyx_mstate_global->__pyx_n_s_Function__input_price_series_na -#define __pyx_n_s_Function__local __pyx_mstate_global->__pyx_n_s_Function__local -#define __pyx_n_s_Function__localdata __pyx_mstate_global->__pyx_n_s_Function__localdata -#define __pyx_n_s_Function__name __pyx_mstate_global->__pyx_n_s_Function__name -#define __pyx_n_s_Function__namestr __pyx_mstate_global->__pyx_n_s_Function__namestr -#define __pyx_n_s_Function_function_flags __pyx_mstate_global->__pyx_n_s_Function_function_flags -#define __pyx_n_s_Function_get_input_arrays __pyx_mstate_global->__pyx_n_s_Function_get_input_arrays -#define __pyx_n_s_Function_get_input_names __pyx_mstate_global->__pyx_n_s_Function_get_input_names -#define __pyx_n_s_Function_get_parameters __pyx_mstate_global->__pyx_n_s_Function_get_parameters -#define __pyx_kp_s_Function_has_an_unstable_period __pyx_mstate_global->__pyx_kp_s_Function_has_an_unstable_period -#define __pyx_n_s_Function_info __pyx_mstate_global->__pyx_n_s_Function_info -#define __pyx_n_s_Function_lookback __pyx_mstate_global->__pyx_n_s_Function_lookback -#define __pyx_n_s_Function_output_flags __pyx_mstate_global->__pyx_n_s_Function_output_flags -#define __pyx_n_s_Function_output_names __pyx_mstate_global->__pyx_n_s_Function_output_names -#define __pyx_n_s_Function_outputs __pyx_mstate_global->__pyx_n_s_Function_outputs -#define __pyx_n_s_Function_run __pyx_mstate_global->__pyx_n_s_Function_run -#define __pyx_n_s_Function_set_function_args __pyx_mstate_global->__pyx_n_s_Function_set_function_args -#define __pyx_n_s_Function_set_input_arrays __pyx_mstate_global->__pyx_n_s_Function_set_input_arrays -#define __pyx_n_s_Function_set_input_names __pyx_mstate_global->__pyx_n_s_Function_set_input_names -#define __pyx_n_s_Function_set_parameters __pyx_mstate_global->__pyx_n_s_Function_set_parameters -#define __pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU __pyx_mstate_global->__pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU -#define __pyx_n_s_HT_DCPERIOD __pyx_mstate_global->__pyx_n_s_HT_DCPERIOD -#define __pyx_n_s_HT_DCPHASE __pyx_mstate_global->__pyx_n_s_HT_DCPHASE -#define __pyx_n_s_HT_PHASOR __pyx_mstate_global->__pyx_n_s_HT_PHASOR -#define __pyx_n_s_HT_SINE __pyx_mstate_global->__pyx_n_s_HT_SINE -#define __pyx_n_s_HT_TRENDLINE __pyx_mstate_global->__pyx_n_s_HT_TRENDLINE -#define __pyx_n_s_HT_TRENDMODE __pyx_mstate_global->__pyx_n_s_HT_TRENDMODE -#define __pyx_n_s_HighLow __pyx_mstate_global->__pyx_n_s_HighLow -#define __pyx_n_s_Histogram __pyx_mstate_global->__pyx_n_s_Histogram -#define __pyx_n_s_INPUT_ARRAYS_TYPES __pyx_mstate_global->__pyx_n_s_INPUT_ARRAYS_TYPES -#define __pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS __pyx_mstate_global->__pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS -#define __pyx_n_s_ImportError __pyx_mstate_global->__pyx_n_s_ImportError -#define __pyx_n_s_IndexError __pyx_mstate_global->__pyx_n_s_IndexError -#define __pyx_kp_s_Input_Not_All_Initialized_TA_INP __pyx_mstate_global->__pyx_kp_s_Input_Not_All_Initialized_TA_INP -#define __pyx_kp_s_Inputs __pyx_mstate_global->__pyx_kp_s_Inputs -#define __pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR __pyx_mstate_global->__pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR -#define __pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE __pyx_mstate_global->__pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE -#define __pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS __pyx_mstate_global->__pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS -#define __pyx_kp_s_Invalid_Parameter_Function_TA_IN __pyx_mstate_global->__pyx_kp_s_Invalid_Parameter_Function_TA_IN -#define __pyx_kp_s_Invalid_Parameter_Holder_TA_INVA __pyx_mstate_global->__pyx_kp_s_Invalid_Parameter_Holder_TA_INVA -#define __pyx_kp_s_Invalid_Parameter_Holder_Type_TA __pyx_mstate_global->__pyx_kp_s_Invalid_Parameter_Holder_Type_TA -#define __pyx_kp_s_Invalid_parameter_value_for_s_ex __pyx_mstate_global->__pyx_kp_s_Invalid_parameter_value_for_s_ex -#define __pyx_n_s_KAMA __pyx_mstate_global->__pyx_n_s_KAMA -#define __pyx_kp_s_Kaufman_Adaptive_Moving_Average __pyx_mstate_global->__pyx_kp_s_Kaufman_Adaptive_Moving_Average -#define __pyx_n_s_LINEARREG __pyx_mstate_global->__pyx_n_s_LINEARREG -#define __pyx_n_s_LINEARREG_ANGLE __pyx_mstate_global->__pyx_n_s_LINEARREG_ANGLE -#define __pyx_n_s_LINEARREG_INTERCEPT __pyx_mstate_global->__pyx_n_s_LINEARREG_INTERCEPT -#define __pyx_n_s_LINEARREG_SLOPE __pyx_mstate_global->__pyx_n_s_LINEARREG_SLOPE -#define __pyx_n_s_LN __pyx_mstate_global->__pyx_n_s_LN -#define __pyx_n_s_LOG10 __pyx_mstate_global->__pyx_n_s_LOG10 -#define __pyx_kp_s_Library_Not_Initialized_TA_LIB_N __pyx_mstate_global->__pyx_kp_s_Library_Not_Initialized_TA_LIB_N -#define __pyx_n_s_Line __pyx_mstate_global->__pyx_n_s_Line -#define __pyx_n_s_MA __pyx_mstate_global->__pyx_n_s_MA -#define __pyx_n_s_MACD __pyx_mstate_global->__pyx_n_s_MACD -#define __pyx_n_s_MACDEXT __pyx_mstate_global->__pyx_n_s_MACDEXT -#define __pyx_n_s_MACDFIX __pyx_mstate_global->__pyx_n_s_MACDFIX -#define __pyx_n_s_MAMA __pyx_mstate_global->__pyx_n_s_MAMA -#define __pyx_n_s_MAVP __pyx_mstate_global->__pyx_n_s_MAVP -#define __pyx_n_s_MAX __pyx_mstate_global->__pyx_n_s_MAX -#define __pyx_n_s_MAXINDEX __pyx_mstate_global->__pyx_n_s_MAXINDEX -#define __pyx_n_s_MA_Type __pyx_mstate_global->__pyx_n_s_MA_Type -#define __pyx_n_s_MA_Type___getitem __pyx_mstate_global->__pyx_n_s_MA_Type___getitem -#define __pyx_n_s_MA_Type___init __pyx_mstate_global->__pyx_n_s_MA_Type___init -#define __pyx_n_s_MEDPRICE __pyx_mstate_global->__pyx_n_s_MEDPRICE -#define __pyx_kp_s_MESA_Adaptive_Moving_Average __pyx_mstate_global->__pyx_kp_s_MESA_Adaptive_Moving_Average -#define __pyx_n_s_MFI __pyx_mstate_global->__pyx_n_s_MFI -#define __pyx_n_s_MIDPOINT __pyx_mstate_global->__pyx_n_s_MIDPOINT -#define __pyx_n_s_MIDPRICE __pyx_mstate_global->__pyx_n_s_MIDPRICE -#define __pyx_n_s_MIN __pyx_mstate_global->__pyx_n_s_MIN -#define __pyx_n_s_MININDEX __pyx_mstate_global->__pyx_n_s_MININDEX -#define __pyx_n_s_MINMAX __pyx_mstate_global->__pyx_n_s_MINMAX -#define __pyx_n_s_MINMAXINDEX __pyx_mstate_global->__pyx_n_s_MINMAXINDEX -#define __pyx_n_s_MINUS_DI __pyx_mstate_global->__pyx_n_s_MINUS_DI -#define __pyx_n_s_MINUS_DM __pyx_mstate_global->__pyx_n_s_MINUS_DM -#define __pyx_n_s_MOM __pyx_mstate_global->__pyx_n_s_MOM -#define __pyx_n_s_MULT __pyx_mstate_global->__pyx_n_s_MULT -#define __pyx_n_s_NATR __pyx_mstate_global->__pyx_n_s_NATR -#define __pyx_n_s_NONE __pyx_mstate_global->__pyx_n_s_NONE -#define __pyx_n_s_Near __pyx_mstate_global->__pyx_n_s_Near -#define __pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED __pyx_mstate_global->__pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED -#define __pyx_kp_s_Not_enough_price_arguments_expec __pyx_mstate_global->__pyx_kp_s_Not_enough_price_arguments_expec -#define __pyx_n_s_OBV __pyx_mstate_global->__pyx_n_s_OBV -#define __pyx_n_s_OrderedDict __pyx_mstate_global->__pyx_n_s_OrderedDict -#define __pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF __pyx_mstate_global->__pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF -#define __pyx_kp_s_Out_of_Range_Start_Index_TA_OUT __pyx_mstate_global->__pyx_kp_s_Out_of_Range_Start_Index_TA_OUT -#define __pyx_kp_s_Output_Not_All_Initialized_TA_OU __pyx_mstate_global->__pyx_kp_s_Output_Not_All_Initialized_TA_OU -#define __pyx_kp_s_Output_can_be_negative __pyx_mstate_global->__pyx_kp_s_Output_can_be_negative -#define __pyx_kp_s_Output_can_be_positive __pyx_mstate_global->__pyx_kp_s_Output_can_be_positive -#define __pyx_kp_s_Output_can_be_zero __pyx_mstate_global->__pyx_kp_s_Output_can_be_zero -#define __pyx_kp_s_Output_is_a_candlestick __pyx_mstate_global->__pyx_kp_s_Output_is_a_candlestick -#define __pyx_kp_s_Output_is_over_volume __pyx_mstate_global->__pyx_kp_s_Output_is_over_volume -#define __pyx_kp_s_Output_scale_same_as_input __pyx_mstate_global->__pyx_kp_s_Output_scale_same_as_input -#define __pyx_kp_s_Outputs __pyx_mstate_global->__pyx_kp_s_Outputs -#define __pyx_n_s_PANDAS_DATAFRAME __pyx_mstate_global->__pyx_n_s_PANDAS_DATAFRAME -#define __pyx_n_s_PANDAS_SERIES __pyx_mstate_global->__pyx_n_s_PANDAS_SERIES -#define __pyx_n_s_PLUS_DI __pyx_mstate_global->__pyx_n_s_PLUS_DI -#define __pyx_n_s_PLUS_DM __pyx_mstate_global->__pyx_n_s_PLUS_DM -#define __pyx_n_s_POLARS_DATAFRAME __pyx_mstate_global->__pyx_n_s_POLARS_DATAFRAME -#define __pyx_n_s_POLARS_SERIES __pyx_mstate_global->__pyx_n_s_POLARS_SERIES -#define __pyx_n_s_PPO __pyx_mstate_global->__pyx_n_s_PPO -#define __pyx_kp_s_Parameters __pyx_mstate_global->__pyx_kp_s_Parameters -#define __pyx_kp_s_Pattern_Bool __pyx_mstate_global->__pyx_kp_s_Pattern_Bool -#define __pyx_n_s_ROC __pyx_mstate_global->__pyx_n_s_ROC -#define __pyx_n_s_ROCP __pyx_mstate_global->__pyx_n_s_ROCP -#define __pyx_n_s_ROCR __pyx_mstate_global->__pyx_n_s_ROCR -#define __pyx_n_s_ROCR100 __pyx_mstate_global->__pyx_n_s_ROCR100 -#define __pyx_n_s_RSI __pyx_mstate_global->__pyx_n_s_RSI -#define __pyx_n_s_RangeType __pyx_mstate_global->__pyx_n_s_RangeType -#define __pyx_n_s_RealBody __pyx_mstate_global->__pyx_n_s_RealBody -#define __pyx_n_s_SAR __pyx_mstate_global->__pyx_n_s_SAR -#define __pyx_n_s_SAREXT __pyx_mstate_global->__pyx_n_s_SAREXT -#define __pyx_n_s_SIN __pyx_mstate_global->__pyx_n_s_SIN -#define __pyx_n_s_SINH __pyx_mstate_global->__pyx_n_s_SINH -#define __pyx_n_s_SMA __pyx_mstate_global->__pyx_n_s_SMA -#define __pyx_n_s_SQRT __pyx_mstate_global->__pyx_n_s_SQRT -#define __pyx_n_s_STDDEV __pyx_mstate_global->__pyx_n_s_STDDEV -#define __pyx_n_s_STOCH __pyx_mstate_global->__pyx_n_s_STOCH -#define __pyx_n_s_STOCHF __pyx_mstate_global->__pyx_n_s_STOCHF -#define __pyx_n_s_STOCHRSI __pyx_mstate_global->__pyx_n_s_STOCHRSI -#define __pyx_n_s_SUB __pyx_mstate_global->__pyx_n_s_SUB -#define __pyx_n_s_SUM __pyx_mstate_global->__pyx_n_s_SUM -#define __pyx_n_s_Series __pyx_mstate_global->__pyx_n_s_Series -#define __pyx_n_s_ShadowLong __pyx_mstate_global->__pyx_n_s_ShadowLong -#define __pyx_n_s_ShadowShort __pyx_mstate_global->__pyx_n_s_ShadowShort -#define __pyx_n_s_ShadowVeryLong __pyx_mstate_global->__pyx_n_s_ShadowVeryLong -#define __pyx_n_s_ShadowVeryShort __pyx_mstate_global->__pyx_n_s_ShadowVeryShort -#define __pyx_n_s_Shadows __pyx_mstate_global->__pyx_n_s_Shadows -#define __pyx_kp_s_Simple_Moving_Average __pyx_mstate_global->__pyx_kp_s_Simple_Moving_Average -#define __pyx_kp_s_Strength_Pattern_200_100_Bearish __pyx_mstate_global->__pyx_kp_s_Strength_Pattern_200_100_Bearish -#define __pyx_n_s_T3 __pyx_mstate_global->__pyx_n_s_T3 -#define __pyx_n_s_TAN __pyx_mstate_global->__pyx_n_s_TAN -#define __pyx_n_s_TANH __pyx_mstate_global->__pyx_n_s_TANH -#define __pyx_n_s_TA_ACOS __pyx_mstate_global->__pyx_n_s_TA_ACOS -#define __pyx_n_s_TA_AD __pyx_mstate_global->__pyx_n_s_TA_AD -#define __pyx_n_s_TA_ADD __pyx_mstate_global->__pyx_n_s_TA_ADD -#define __pyx_n_s_TA_ADOSC __pyx_mstate_global->__pyx_n_s_TA_ADOSC -#define __pyx_n_s_TA_ADX __pyx_mstate_global->__pyx_n_s_TA_ADX -#define __pyx_n_s_TA_ADXR __pyx_mstate_global->__pyx_n_s_TA_ADXR -#define __pyx_n_s_TA_APO __pyx_mstate_global->__pyx_n_s_TA_APO -#define __pyx_n_s_TA_AROON __pyx_mstate_global->__pyx_n_s_TA_AROON -#define __pyx_n_s_TA_AROONOSC __pyx_mstate_global->__pyx_n_s_TA_AROONOSC -#define __pyx_n_s_TA_ASIN __pyx_mstate_global->__pyx_n_s_TA_ASIN -#define __pyx_n_s_TA_ATAN __pyx_mstate_global->__pyx_n_s_TA_ATAN -#define __pyx_n_s_TA_ATR __pyx_mstate_global->__pyx_n_s_TA_ATR -#define __pyx_n_s_TA_AVGPRICE __pyx_mstate_global->__pyx_n_s_TA_AVGPRICE -#define __pyx_n_s_TA_BBANDS __pyx_mstate_global->__pyx_n_s_TA_BBANDS -#define __pyx_n_s_TA_BETA __pyx_mstate_global->__pyx_n_s_TA_BETA -#define __pyx_n_s_TA_BOP __pyx_mstate_global->__pyx_n_s_TA_BOP -#define __pyx_n_s_TA_CCI __pyx_mstate_global->__pyx_n_s_TA_CCI -#define __pyx_n_s_TA_CDL2CROWS __pyx_mstate_global->__pyx_n_s_TA_CDL2CROWS -#define __pyx_n_s_TA_CDL3BLACKCROWS __pyx_mstate_global->__pyx_n_s_TA_CDL3BLACKCROWS -#define __pyx_n_s_TA_CDL3INSIDE __pyx_mstate_global->__pyx_n_s_TA_CDL3INSIDE -#define __pyx_n_s_TA_CDL3LINESTRIKE __pyx_mstate_global->__pyx_n_s_TA_CDL3LINESTRIKE -#define __pyx_n_s_TA_CDL3OUTSIDE __pyx_mstate_global->__pyx_n_s_TA_CDL3OUTSIDE -#define __pyx_n_s_TA_CDL3STARSINSOUTH __pyx_mstate_global->__pyx_n_s_TA_CDL3STARSINSOUTH -#define __pyx_n_s_TA_CDL3WHITESOLDIERS __pyx_mstate_global->__pyx_n_s_TA_CDL3WHITESOLDIERS -#define __pyx_n_s_TA_CDLABANDONEDBABY __pyx_mstate_global->__pyx_n_s_TA_CDLABANDONEDBABY -#define __pyx_n_s_TA_CDLADVANCEBLOCK __pyx_mstate_global->__pyx_n_s_TA_CDLADVANCEBLOCK -#define __pyx_n_s_TA_CDLBELTHOLD __pyx_mstate_global->__pyx_n_s_TA_CDLBELTHOLD -#define __pyx_n_s_TA_CDLBREAKAWAY __pyx_mstate_global->__pyx_n_s_TA_CDLBREAKAWAY -#define __pyx_n_s_TA_CDLCLOSINGMARUBOZU __pyx_mstate_global->__pyx_n_s_TA_CDLCLOSINGMARUBOZU -#define __pyx_n_s_TA_CDLCONCEALBABYSWALL __pyx_mstate_global->__pyx_n_s_TA_CDLCONCEALBABYSWALL -#define __pyx_n_s_TA_CDLCOUNTERATTACK __pyx_mstate_global->__pyx_n_s_TA_CDLCOUNTERATTACK -#define __pyx_n_s_TA_CDLDARKCLOUDCOVER __pyx_mstate_global->__pyx_n_s_TA_CDLDARKCLOUDCOVER -#define __pyx_n_s_TA_CDLDOJI __pyx_mstate_global->__pyx_n_s_TA_CDLDOJI -#define __pyx_n_s_TA_CDLDOJISTAR __pyx_mstate_global->__pyx_n_s_TA_CDLDOJISTAR -#define __pyx_n_s_TA_CDLDRAGONFLYDOJI __pyx_mstate_global->__pyx_n_s_TA_CDLDRAGONFLYDOJI -#define __pyx_n_s_TA_CDLENGULFING __pyx_mstate_global->__pyx_n_s_TA_CDLENGULFING -#define __pyx_n_s_TA_CDLEVENINGDOJISTAR __pyx_mstate_global->__pyx_n_s_TA_CDLEVENINGDOJISTAR -#define __pyx_n_s_TA_CDLEVENINGSTAR __pyx_mstate_global->__pyx_n_s_TA_CDLEVENINGSTAR -#define __pyx_n_s_TA_CDLGAPSIDESIDEWHITE __pyx_mstate_global->__pyx_n_s_TA_CDLGAPSIDESIDEWHITE -#define __pyx_n_s_TA_CDLGRAVESTONEDOJI __pyx_mstate_global->__pyx_n_s_TA_CDLGRAVESTONEDOJI -#define __pyx_n_s_TA_CDLHAMMER __pyx_mstate_global->__pyx_n_s_TA_CDLHAMMER -#define __pyx_n_s_TA_CDLHANGINGMAN __pyx_mstate_global->__pyx_n_s_TA_CDLHANGINGMAN -#define __pyx_n_s_TA_CDLHARAMI __pyx_mstate_global->__pyx_n_s_TA_CDLHARAMI -#define __pyx_n_s_TA_CDLHARAMICROSS __pyx_mstate_global->__pyx_n_s_TA_CDLHARAMICROSS -#define __pyx_n_s_TA_CDLHIGHWAVE __pyx_mstate_global->__pyx_n_s_TA_CDLHIGHWAVE -#define __pyx_n_s_TA_CDLHIKKAKE __pyx_mstate_global->__pyx_n_s_TA_CDLHIKKAKE -#define __pyx_n_s_TA_CDLHIKKAKEMOD __pyx_mstate_global->__pyx_n_s_TA_CDLHIKKAKEMOD -#define __pyx_n_s_TA_CDLHOMINGPIGEON __pyx_mstate_global->__pyx_n_s_TA_CDLHOMINGPIGEON -#define __pyx_n_s_TA_CDLIDENTICAL3CROWS __pyx_mstate_global->__pyx_n_s_TA_CDLIDENTICAL3CROWS -#define __pyx_n_s_TA_CDLINNECK __pyx_mstate_global->__pyx_n_s_TA_CDLINNECK -#define __pyx_n_s_TA_CDLINVERTEDHAMMER __pyx_mstate_global->__pyx_n_s_TA_CDLINVERTEDHAMMER -#define __pyx_n_s_TA_CDLKICKING __pyx_mstate_global->__pyx_n_s_TA_CDLKICKING -#define __pyx_n_s_TA_CDLKICKINGBYLENGTH __pyx_mstate_global->__pyx_n_s_TA_CDLKICKINGBYLENGTH -#define __pyx_n_s_TA_CDLLADDERBOTTOM __pyx_mstate_global->__pyx_n_s_TA_CDLLADDERBOTTOM -#define __pyx_n_s_TA_CDLLONGLEGGEDDOJI __pyx_mstate_global->__pyx_n_s_TA_CDLLONGLEGGEDDOJI -#define __pyx_n_s_TA_CDLLONGLINE __pyx_mstate_global->__pyx_n_s_TA_CDLLONGLINE -#define __pyx_n_s_TA_CDLMARUBOZU __pyx_mstate_global->__pyx_n_s_TA_CDLMARUBOZU -#define __pyx_n_s_TA_CDLMATCHINGLOW __pyx_mstate_global->__pyx_n_s_TA_CDLMATCHINGLOW -#define __pyx_n_s_TA_CDLMATHOLD __pyx_mstate_global->__pyx_n_s_TA_CDLMATHOLD -#define __pyx_n_s_TA_CDLMORNINGDOJISTAR __pyx_mstate_global->__pyx_n_s_TA_CDLMORNINGDOJISTAR -#define __pyx_n_s_TA_CDLMORNINGSTAR __pyx_mstate_global->__pyx_n_s_TA_CDLMORNINGSTAR -#define __pyx_n_s_TA_CDLONNECK __pyx_mstate_global->__pyx_n_s_TA_CDLONNECK -#define __pyx_n_s_TA_CDLPIERCING __pyx_mstate_global->__pyx_n_s_TA_CDLPIERCING -#define __pyx_n_s_TA_CDLRICKSHAWMAN __pyx_mstate_global->__pyx_n_s_TA_CDLRICKSHAWMAN -#define __pyx_n_s_TA_CDLRISEFALL3METHODS __pyx_mstate_global->__pyx_n_s_TA_CDLRISEFALL3METHODS -#define __pyx_n_s_TA_CDLSEPARATINGLINES __pyx_mstate_global->__pyx_n_s_TA_CDLSEPARATINGLINES -#define __pyx_n_s_TA_CDLSHOOTINGSTAR __pyx_mstate_global->__pyx_n_s_TA_CDLSHOOTINGSTAR -#define __pyx_n_s_TA_CDLSHORTLINE __pyx_mstate_global->__pyx_n_s_TA_CDLSHORTLINE -#define __pyx_n_s_TA_CDLSPINNINGTOP __pyx_mstate_global->__pyx_n_s_TA_CDLSPINNINGTOP -#define __pyx_n_s_TA_CDLSTALLEDPATTERN __pyx_mstate_global->__pyx_n_s_TA_CDLSTALLEDPATTERN -#define __pyx_n_s_TA_CDLSTICKSANDWICH __pyx_mstate_global->__pyx_n_s_TA_CDLSTICKSANDWICH -#define __pyx_n_s_TA_CDLTAKURI __pyx_mstate_global->__pyx_n_s_TA_CDLTAKURI -#define __pyx_n_s_TA_CDLTASUKIGAP __pyx_mstate_global->__pyx_n_s_TA_CDLTASUKIGAP -#define __pyx_n_s_TA_CDLTHRUSTING __pyx_mstate_global->__pyx_n_s_TA_CDLTHRUSTING -#define __pyx_n_s_TA_CDLTRISTAR __pyx_mstate_global->__pyx_n_s_TA_CDLTRISTAR -#define __pyx_n_s_TA_CDLUNIQUE3RIVER __pyx_mstate_global->__pyx_n_s_TA_CDLUNIQUE3RIVER -#define __pyx_n_s_TA_CDLUPSIDEGAP2CROWS __pyx_mstate_global->__pyx_n_s_TA_CDLUPSIDEGAP2CROWS -#define __pyx_n_s_TA_CDLXSIDEGAP3METHODS __pyx_mstate_global->__pyx_n_s_TA_CDLXSIDEGAP3METHODS -#define __pyx_n_s_TA_CEIL __pyx_mstate_global->__pyx_n_s_TA_CEIL -#define __pyx_n_s_TA_CMO __pyx_mstate_global->__pyx_n_s_TA_CMO -#define __pyx_n_s_TA_CORREL __pyx_mstate_global->__pyx_n_s_TA_CORREL -#define __pyx_n_s_TA_COS __pyx_mstate_global->__pyx_n_s_TA_COS -#define __pyx_n_s_TA_COSH __pyx_mstate_global->__pyx_n_s_TA_COSH -#define __pyx_n_s_TA_DEMA __pyx_mstate_global->__pyx_n_s_TA_DEMA -#define __pyx_n_s_TA_DIV __pyx_mstate_global->__pyx_n_s_TA_DIV -#define __pyx_n_s_TA_DX __pyx_mstate_global->__pyx_n_s_TA_DX -#define __pyx_n_s_TA_EMA __pyx_mstate_global->__pyx_n_s_TA_EMA -#define __pyx_n_s_TA_EXP __pyx_mstate_global->__pyx_n_s_TA_EXP -#define __pyx_n_s_TA_FLOOR __pyx_mstate_global->__pyx_n_s_TA_FLOOR -#define __pyx_n_s_TA_FUNCTION_NAMES __pyx_mstate_global->__pyx_n_s_TA_FUNCTION_NAMES -#define __pyx_n_s_TA_FUNC_FLAGS __pyx_mstate_global->__pyx_n_s_TA_FUNC_FLAGS -#define __pyx_n_s_TA_FuncTableAlloc __pyx_mstate_global->__pyx_n_s_TA_FuncTableAlloc -#define __pyx_n_s_TA_FuncTableFree __pyx_mstate_global->__pyx_n_s_TA_FuncTableFree -#define __pyx_n_s_TA_GetFuncHandle __pyx_mstate_global->__pyx_n_s_TA_GetFuncHandle -#define __pyx_n_s_TA_GetFuncInfo __pyx_mstate_global->__pyx_n_s_TA_GetFuncInfo -#define __pyx_n_s_TA_GetInputParameterInfo __pyx_mstate_global->__pyx_n_s_TA_GetInputParameterInfo -#define __pyx_n_s_TA_GetLookback __pyx_mstate_global->__pyx_n_s_TA_GetLookback -#define __pyx_n_s_TA_GetOptInputParameterInfo __pyx_mstate_global->__pyx_n_s_TA_GetOptInputParameterInfo -#define __pyx_n_s_TA_GetOutputParameterInfo __pyx_mstate_global->__pyx_n_s_TA_GetOutputParameterInfo -#define __pyx_n_s_TA_GroupTableAlloc __pyx_mstate_global->__pyx_n_s_TA_GroupTableAlloc -#define __pyx_n_s_TA_GroupTableFree __pyx_mstate_global->__pyx_n_s_TA_GroupTableFree -#define __pyx_n_s_TA_HT_DCPERIOD __pyx_mstate_global->__pyx_n_s_TA_HT_DCPERIOD -#define __pyx_n_s_TA_HT_DCPHASE __pyx_mstate_global->__pyx_n_s_TA_HT_DCPHASE -#define __pyx_n_s_TA_HT_PHASOR __pyx_mstate_global->__pyx_n_s_TA_HT_PHASOR -#define __pyx_n_s_TA_HT_SINE __pyx_mstate_global->__pyx_n_s_TA_HT_SINE -#define __pyx_n_s_TA_HT_TRENDLINE __pyx_mstate_global->__pyx_n_s_TA_HT_TRENDLINE -#define __pyx_n_s_TA_HT_TRENDMODE __pyx_mstate_global->__pyx_n_s_TA_HT_TRENDMODE -#define __pyx_n_s_TA_INPUT_FLAGS __pyx_mstate_global->__pyx_n_s_TA_INPUT_FLAGS -#define __pyx_n_s_TA_Initialize __pyx_mstate_global->__pyx_n_s_TA_Initialize -#define __pyx_n_s_TA_KAMA __pyx_mstate_global->__pyx_n_s_TA_KAMA -#define __pyx_n_s_TA_LINEARREG __pyx_mstate_global->__pyx_n_s_TA_LINEARREG -#define __pyx_n_s_TA_LINEARREG_ANGLE __pyx_mstate_global->__pyx_n_s_TA_LINEARREG_ANGLE -#define __pyx_n_s_TA_LINEARREG_INTERCEPT __pyx_mstate_global->__pyx_n_s_TA_LINEARREG_INTERCEPT -#define __pyx_n_s_TA_LINEARREG_SLOPE __pyx_mstate_global->__pyx_n_s_TA_LINEARREG_SLOPE -#define __pyx_n_s_TA_LN __pyx_mstate_global->__pyx_n_s_TA_LN -#define __pyx_n_s_TA_LOG10 __pyx_mstate_global->__pyx_n_s_TA_LOG10 -#define __pyx_n_s_TA_MA __pyx_mstate_global->__pyx_n_s_TA_MA -#define __pyx_n_s_TA_MACD __pyx_mstate_global->__pyx_n_s_TA_MACD -#define __pyx_n_s_TA_MACDEXT __pyx_mstate_global->__pyx_n_s_TA_MACDEXT -#define __pyx_n_s_TA_MACDFIX __pyx_mstate_global->__pyx_n_s_TA_MACDFIX -#define __pyx_n_s_TA_MAMA __pyx_mstate_global->__pyx_n_s_TA_MAMA -#define __pyx_n_s_TA_MAVP __pyx_mstate_global->__pyx_n_s_TA_MAVP -#define __pyx_n_s_TA_MAX __pyx_mstate_global->__pyx_n_s_TA_MAX -#define __pyx_n_s_TA_MAXINDEX __pyx_mstate_global->__pyx_n_s_TA_MAXINDEX -#define __pyx_n_s_TA_MEDPRICE __pyx_mstate_global->__pyx_n_s_TA_MEDPRICE -#define __pyx_n_s_TA_MFI __pyx_mstate_global->__pyx_n_s_TA_MFI -#define __pyx_n_s_TA_MIDPOINT __pyx_mstate_global->__pyx_n_s_TA_MIDPOINT -#define __pyx_n_s_TA_MIDPRICE __pyx_mstate_global->__pyx_n_s_TA_MIDPRICE -#define __pyx_n_s_TA_MIN __pyx_mstate_global->__pyx_n_s_TA_MIN -#define __pyx_n_s_TA_MININDEX __pyx_mstate_global->__pyx_n_s_TA_MININDEX -#define __pyx_n_s_TA_MINMAX __pyx_mstate_global->__pyx_n_s_TA_MINMAX -#define __pyx_n_s_TA_MINMAXINDEX __pyx_mstate_global->__pyx_n_s_TA_MINMAXINDEX -#define __pyx_n_s_TA_MINUS_DI __pyx_mstate_global->__pyx_n_s_TA_MINUS_DI -#define __pyx_n_s_TA_MINUS_DM __pyx_mstate_global->__pyx_n_s_TA_MINUS_DM -#define __pyx_n_s_TA_MOM __pyx_mstate_global->__pyx_n_s_TA_MOM -#define __pyx_n_s_TA_MULT __pyx_mstate_global->__pyx_n_s_TA_MULT -#define __pyx_n_s_TA_NATR __pyx_mstate_global->__pyx_n_s_TA_NATR -#define __pyx_n_s_TA_OBV __pyx_mstate_global->__pyx_n_s_TA_OBV -#define __pyx_n_s_TA_OUTPUT_FLAGS __pyx_mstate_global->__pyx_n_s_TA_OUTPUT_FLAGS -#define __pyx_n_s_TA_PLUS_DI __pyx_mstate_global->__pyx_n_s_TA_PLUS_DI -#define __pyx_n_s_TA_PLUS_DM __pyx_mstate_global->__pyx_n_s_TA_PLUS_DM -#define __pyx_n_s_TA_PPO __pyx_mstate_global->__pyx_n_s_TA_PPO -#define __pyx_n_s_TA_ParamHolderAlloc __pyx_mstate_global->__pyx_n_s_TA_ParamHolderAlloc -#define __pyx_n_s_TA_ParamHolderFree __pyx_mstate_global->__pyx_n_s_TA_ParamHolderFree -#define __pyx_n_s_TA_ROC __pyx_mstate_global->__pyx_n_s_TA_ROC -#define __pyx_n_s_TA_ROCP __pyx_mstate_global->__pyx_n_s_TA_ROCP -#define __pyx_n_s_TA_ROCR __pyx_mstate_global->__pyx_n_s_TA_ROCR -#define __pyx_n_s_TA_ROCR100 __pyx_mstate_global->__pyx_n_s_TA_ROCR100 -#define __pyx_n_s_TA_RSI __pyx_mstate_global->__pyx_n_s_TA_RSI -#define __pyx_n_s_TA_RestoreCandleDefaultSettings __pyx_mstate_global->__pyx_n_s_TA_RestoreCandleDefaultSettings -#define __pyx_n_s_TA_SAR __pyx_mstate_global->__pyx_n_s_TA_SAR -#define __pyx_n_s_TA_SAREXT __pyx_mstate_global->__pyx_n_s_TA_SAREXT -#define __pyx_n_s_TA_SIN __pyx_mstate_global->__pyx_n_s_TA_SIN -#define __pyx_n_s_TA_SINH __pyx_mstate_global->__pyx_n_s_TA_SINH -#define __pyx_n_s_TA_SMA __pyx_mstate_global->__pyx_n_s_TA_SMA -#define __pyx_n_s_TA_SQRT __pyx_mstate_global->__pyx_n_s_TA_SQRT -#define __pyx_n_s_TA_STDDEV __pyx_mstate_global->__pyx_n_s_TA_STDDEV -#define __pyx_n_s_TA_STOCH __pyx_mstate_global->__pyx_n_s_TA_STOCH -#define __pyx_n_s_TA_STOCHF __pyx_mstate_global->__pyx_n_s_TA_STOCHF -#define __pyx_n_s_TA_STOCHRSI __pyx_mstate_global->__pyx_n_s_TA_STOCHRSI -#define __pyx_n_s_TA_SUB __pyx_mstate_global->__pyx_n_s_TA_SUB -#define __pyx_n_s_TA_SUM __pyx_mstate_global->__pyx_n_s_TA_SUM -#define __pyx_n_s_TA_SetCandleSettings __pyx_mstate_global->__pyx_n_s_TA_SetCandleSettings -#define __pyx_n_s_TA_SetCompatibility __pyx_mstate_global->__pyx_n_s_TA_SetCompatibility -#define __pyx_n_s_TA_SetOptInputParamInteger __pyx_mstate_global->__pyx_n_s_TA_SetOptInputParamInteger -#define __pyx_n_s_TA_SetOptInputParamReal __pyx_mstate_global->__pyx_n_s_TA_SetOptInputParamReal -#define __pyx_n_s_TA_SetUnstablePeriod __pyx_mstate_global->__pyx_n_s_TA_SetUnstablePeriod -#define __pyx_n_s_TA_Shutdown __pyx_mstate_global->__pyx_n_s_TA_Shutdown -#define __pyx_n_s_TA_T3 __pyx_mstate_global->__pyx_n_s_TA_T3 -#define __pyx_n_s_TA_TAN __pyx_mstate_global->__pyx_n_s_TA_TAN -#define __pyx_n_s_TA_TANH __pyx_mstate_global->__pyx_n_s_TA_TANH -#define __pyx_n_s_TA_TEMA __pyx_mstate_global->__pyx_n_s_TA_TEMA -#define __pyx_n_s_TA_TRANGE __pyx_mstate_global->__pyx_n_s_TA_TRANGE -#define __pyx_n_s_TA_TRIMA __pyx_mstate_global->__pyx_n_s_TA_TRIMA -#define __pyx_n_s_TA_TRIX __pyx_mstate_global->__pyx_n_s_TA_TRIX -#define __pyx_n_s_TA_TSF __pyx_mstate_global->__pyx_n_s_TA_TSF -#define __pyx_n_s_TA_TYPPRICE __pyx_mstate_global->__pyx_n_s_TA_TYPPRICE -#define __pyx_n_s_TA_ULTOSC __pyx_mstate_global->__pyx_n_s_TA_ULTOSC -#define __pyx_n_s_TA_VAR __pyx_mstate_global->__pyx_n_s_TA_VAR -#define __pyx_n_s_TA_WCLPRICE __pyx_mstate_global->__pyx_n_s_TA_WCLPRICE -#define __pyx_n_s_TA_WILLR __pyx_mstate_global->__pyx_n_s_TA_WILLR -#define __pyx_n_s_TA_WMA __pyx_mstate_global->__pyx_n_s_TA_WMA -#define __pyx_n_s_TEMA __pyx_mstate_global->__pyx_n_s_TEMA -#define __pyx_n_s_TRANGE __pyx_mstate_global->__pyx_n_s_TRANGE -#define __pyx_n_s_TRIMA __pyx_mstate_global->__pyx_n_s_TRIMA -#define __pyx_n_s_TRIX __pyx_mstate_global->__pyx_n_s_TRIX -#define __pyx_n_s_TSF __pyx_mstate_global->__pyx_n_s_TSF -#define __pyx_n_s_TYPPRICE __pyx_mstate_global->__pyx_n_s_TYPPRICE -#define __pyx_kp_s_This_is_a_pythonic_wrapper_arou __pyx_mstate_global->__pyx_kp_s_This_is_a_pythonic_wrapper_arou -#define __pyx_kp_s_Too_many_price_arguments_expecte __pyx_mstate_global->__pyx_kp_s_Too_many_price_arguments_expecte -#define __pyx_kp_s_Triangular_Moving_Average __pyx_mstate_global->__pyx_kp_s_Triangular_Moving_Average -#define __pyx_kp_s_Triple_Exponential_Moving_Averag __pyx_mstate_global->__pyx_kp_s_Triple_Exponential_Moving_Averag -#define __pyx_kp_s_Triple_Generalized_Double_Expone __pyx_mstate_global->__pyx_kp_s_Triple_Generalized_Double_Expone -#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError -#define __pyx_n_s_ULTOSC __pyx_mstate_global->__pyx_n_s_ULTOSC -#define __pyx_kp_s_Unknown_Error __pyx_mstate_global->__pyx_kp_s_Unknown_Error -#define __pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR __pyx_mstate_global->__pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR -#define __pyx_n_s_VAR __pyx_mstate_global->__pyx_n_s_VAR -#define __pyx_kp_s_Values_represent_a_lower_limit __pyx_mstate_global->__pyx_kp_s_Values_represent_a_lower_limit -#define __pyx_kp_s_Values_represent_an_upper_limit __pyx_mstate_global->__pyx_kp_s_Values_represent_an_upper_limit -#define __pyx_n_s_WCLPRICE __pyx_mstate_global->__pyx_n_s_WCLPRICE -#define __pyx_n_s_WILLR __pyx_mstate_global->__pyx_n_s_WILLR -#define __pyx_n_s_WMA __pyx_mstate_global->__pyx_n_s_WMA -#define __pyx_kp_s_Weighted_Moving_Average __pyx_mstate_global->__pyx_kp_s_Weighted_Moving_Average -#define __pyx_kp_s__10 __pyx_mstate_global->__pyx_kp_s__10 -#define __pyx_kp_s__11 __pyx_mstate_global->__pyx_kp_s__11 -#define __pyx_kp_s__12 __pyx_mstate_global->__pyx_kp_s__12 -#define __pyx_n_s__240 __pyx_mstate_global->__pyx_n_s__240 -#define __pyx_kp_u__43 __pyx_mstate_global->__pyx_kp_u__43 -#define __pyx_n_s__503 __pyx_mstate_global->__pyx_n_s__503 -#define __pyx_kp_s__6 __pyx_mstate_global->__pyx_kp_s__6 -#define __pyx_kp_s__7 __pyx_mstate_global->__pyx_kp_s__7 -#define __pyx_kp_s__9 __pyx_mstate_global->__pyx_kp_s__9 -#define __pyx_n_s_acceleration __pyx_mstate_global->__pyx_n_s_acceleration -#define __pyx_n_s_accelerationinitlong __pyx_mstate_global->__pyx_n_s_accelerationinitlong -#define __pyx_n_s_accelerationinitshort __pyx_mstate_global->__pyx_n_s_accelerationinitshort -#define __pyx_n_s_accelerationlong __pyx_mstate_global->__pyx_n_s_accelerationlong -#define __pyx_n_s_accelerationmaxlong __pyx_mstate_global->__pyx_n_s_accelerationmaxlong -#define __pyx_n_s_accelerationmaxshort __pyx_mstate_global->__pyx_n_s_accelerationmaxshort -#define __pyx_n_s_accelerationshort __pyx_mstate_global->__pyx_n_s_accelerationshort -#define __pyx_n_s_all __pyx_mstate_global->__pyx_n_s_all -#define __pyx_kp_s_any_ndarray __pyx_mstate_global->__pyx_kp_s_any_ndarray -#define __pyx_n_s_append __pyx_mstate_global->__pyx_n_s_append -#define __pyx_n_s_arg __pyx_mstate_global->__pyx_n_s_arg -#define __pyx_n_s_args __pyx_mstate_global->__pyx_n_s_args -#define __pyx_n_s_ascii __pyx_mstate_global->__pyx_n_s_ascii -#define __pyx_n_s_astype __pyx_mstate_global->__pyx_n_s_astype -#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines -#define __pyx_n_s_avgperiod __pyx_mstate_global->__pyx_n_s_avgperiod -#define __pyx_n_s_b __pyx_mstate_global->__pyx_n_s_b -#define __pyx_n_s_begidx __pyx_mstate_global->__pyx_n_s_begidx -#define __pyx_n_s_bytes2str __pyx_mstate_global->__pyx_n_s_bytes2str -#define __pyx_n_s_call __pyx_mstate_global->__pyx_n_s_call -#define __pyx_n_s_call_function __pyx_mstate_global->__pyx_n_s_call_function -#define __pyx_n_s_check_opt_input_value __pyx_mstate_global->__pyx_n_s_check_opt_input_value -#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem -#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback -#define __pyx_n_s_clone __pyx_mstate_global->__pyx_n_s_clone -#define __pyx_n_s_close __pyx_mstate_global->__pyx_n_s_close -#define __pyx_n_s_close_data __pyx_mstate_global->__pyx_n_s_close_data -#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections -#define __pyx_n_s_column_stack __pyx_mstate_global->__pyx_n_s_column_stack -#define __pyx_n_s_columns __pyx_mstate_global->__pyx_n_s_columns -#define __pyx_n_s_copy __pyx_mstate_global->__pyx_n_s_copy -#define __pyx_n_s_decode __pyx_mstate_global->__pyx_n_s_decode -#define __pyx_n_s_default_value __pyx_mstate_global->__pyx_n_s_default_value -#define __pyx_n_s_defaults __pyx_mstate_global->__pyx_n_s_defaults -#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict -#define __pyx_n_s_display_name __pyx_mstate_global->__pyx_n_s_display_name -#define __pyx_kp_s_display_name_s_group_s __pyx_mstate_global->__pyx_kp_s_display_name_s_group_s -#define __pyx_n_s_doc __pyx_mstate_global->__pyx_n_s_doc -#define __pyx_n_s_docs __pyx_mstate_global->__pyx_n_s_docs -#define __pyx_n_s_documentation __pyx_mstate_global->__pyx_n_s_documentation -#define __pyx_n_s_empty __pyx_mstate_global->__pyx_n_s_empty -#define __pyx_n_s_endidx __pyx_mstate_global->__pyx_n_s_endidx -#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate -#define __pyx_n_s_factor __pyx_mstate_global->__pyx_n_s_factor -#define __pyx_n_s_fastd_matype __pyx_mstate_global->__pyx_n_s_fastd_matype -#define __pyx_n_s_fastd_period __pyx_mstate_global->__pyx_n_s_fastd_period -#define __pyx_n_s_fastk_period __pyx_mstate_global->__pyx_n_s_fastk_period -#define __pyx_n_s_fastlimit __pyx_mstate_global->__pyx_n_s_fastlimit -#define __pyx_n_s_fastmatype __pyx_mstate_global->__pyx_n_s_fastmatype -#define __pyx_n_s_fastperiod __pyx_mstate_global->__pyx_n_s_fastperiod -#define __pyx_n_s_flag __pyx_mstate_global->__pyx_n_s_flag -#define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags -#define __pyx_n_s_flags_lookup_dict __pyx_mstate_global->__pyx_n_s_flags_lookup_dict -#define __pyx_n_s_func_args __pyx_mstate_global->__pyx_n_s_func_args -#define __pyx_n_s_func_info __pyx_mstate_global->__pyx_n_s_func_info -#define __pyx_n_s_func_line __pyx_mstate_global->__pyx_n_s_func_line -#define __pyx_n_s_func_object __pyx_mstate_global->__pyx_n_s_func_object -#define __pyx_n_s_function_flags __pyx_mstate_global->__pyx_n_s_function_flags -#define __pyx_n_s_function_name __pyx_mstate_global->__pyx_n_s_function_name -#define __pyx_n_s_functions __pyx_mstate_global->__pyx_n_s_functions -#define __pyx_n_s_get_defaults_and_docs __pyx_mstate_global->__pyx_n_s_get_defaults_and_docs -#define __pyx_n_s_get_flags __pyx_mstate_global->__pyx_n_s_get_flags -#define __pyx_n_s_get_input_arrays __pyx_mstate_global->__pyx_n_s_get_input_arrays -#define __pyx_n_s_get_input_names __pyx_mstate_global->__pyx_n_s_get_input_names -#define __pyx_n_s_get_opt_input_value __pyx_mstate_global->__pyx_n_s_get_opt_input_value -#define __pyx_n_s_get_parameters __pyx_mstate_global->__pyx_n_s_get_parameters -#define __pyx_n_s_getitem __pyx_mstate_global->__pyx_n_s_getitem -#define __pyx_n_s_group __pyx_mstate_global->__pyx_n_s_group -#define __pyx_n_s_groups __pyx_mstate_global->__pyx_n_s_groups -#define __pyx_n_s_help __pyx_mstate_global->__pyx_n_s_help -#define __pyx_n_s_high __pyx_mstate_global->__pyx_n_s_high -#define __pyx_n_s_high_data __pyx_mstate_global->__pyx_n_s_high_data -#define __pyx_n_s_holder __pyx_mstate_global->__pyx_n_s_holder -#define __pyx_n_s_i __pyx_mstate_global->__pyx_n_s_i -#define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id -#define __pyx_n_s_idx __pyx_mstate_global->__pyx_n_s_idx -#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import -#define __pyx_n_s_in __pyx_mstate_global->__pyx_n_s_in -#define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index -#define __pyx_n_s_info __pyx_mstate_global->__pyx_n_s_info -#define __pyx_n_s_init __pyx_mstate_global->__pyx_n_s_init -#define __pyx_n_s_init_subclass __pyx_mstate_global->__pyx_n_s_init_subclass -#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing -#define __pyx_kp_s_input_array_has_wrong_dimensions __pyx_mstate_global->__pyx_kp_s_input_array_has_wrong_dimensions -#define __pyx_kp_s_input_array_lengths_are_differen __pyx_mstate_global->__pyx_kp_s_input_array_lengths_are_differen -#define __pyx_kp_s_input_array_type_is_not_double __pyx_mstate_global->__pyx_kp_s_input_array_type_is_not_double -#define __pyx_n_s_input_arrays __pyx_mstate_global->__pyx_n_s_input_arrays -#define __pyx_kp_s_input_arrays_2 __pyx_mstate_global->__pyx_kp_s_input_arrays_2 -#define __pyx_kp_s_input_arrays_parameter_missing_r __pyx_mstate_global->__pyx_kp_s_input_arrays_parameter_missing_r -#define __pyx_n_s_input_name __pyx_mstate_global->__pyx_n_s_input_name -#define __pyx_n_s_input_names __pyx_mstate_global->__pyx_n_s_input_names -#define __pyx_n_s_input_price_series_names __pyx_mstate_global->__pyx_n_s_input_price_series_names -#define __pyx_n_s_input_price_series_names_2 __pyx_mstate_global->__pyx_n_s_input_price_series_names_2 -#define __pyx_n_s_integer __pyx_mstate_global->__pyx_n_s_integer -#define __pyx_kp_s_integer_values_are_100_0_or_100 __pyx_mstate_global->__pyx_kp_s_integer_values_are_100_0_or_100 -#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine -#define __pyx_n_s_is_empty __pyx_mstate_global->__pyx_n_s_is_empty -#define __pyx_n_s_items __pyx_mstate_global->__pyx_n_s_items -#define __pyx_n_s_join __pyx_mstate_global->__pyx_n_s_join -#define __pyx_n_s_key __pyx_mstate_global->__pyx_n_s_key -#define __pyx_n_s_keys __pyx_mstate_global->__pyx_n_s_keys -#define __pyx_n_s_kwargs __pyx_mstate_global->__pyx_n_s_kwargs -#define __pyx_n_s_length __pyx_mstate_global->__pyx_n_s_length -#define __pyx_n_s_local __pyx_mstate_global->__pyx_n_s_local -#define __pyx_n_s_local_2 __pyx_mstate_global->__pyx_n_s_local_2 -#define __pyx_n_s_log __pyx_mstate_global->__pyx_n_s_log -#define __pyx_n_s_lookback __pyx_mstate_global->__pyx_n_s_lookback -#define __pyx_n_s_lookup __pyx_mstate_global->__pyx_n_s_lookup -#define __pyx_n_s_low __pyx_mstate_global->__pyx_n_s_low -#define __pyx_n_s_low_data __pyx_mstate_global->__pyx_n_s_low_data -#define __pyx_n_s_lower __pyx_mstate_global->__pyx_n_s_lower -#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main -#define __pyx_n_s_math __pyx_mstate_global->__pyx_n_s_math -#define __pyx_n_s_matype __pyx_mstate_global->__pyx_n_s_matype -#define __pyx_n_s_max __pyx_mstate_global->__pyx_n_s_max -#define __pyx_n_s_max_int __pyx_mstate_global->__pyx_n_s_max_int -#define __pyx_n_s_maximum __pyx_mstate_global->__pyx_n_s_maximum -#define __pyx_n_s_maxperiod __pyx_mstate_global->__pyx_n_s_maxperiod -#define __pyx_n_s_metaclass __pyx_mstate_global->__pyx_n_s_metaclass -#define __pyx_n_s_min __pyx_mstate_global->__pyx_n_s_min -#define __pyx_n_s_min_int __pyx_mstate_global->__pyx_n_s_min_int -#define __pyx_n_s_minperiod __pyx_mstate_global->__pyx_n_s_minperiod -#define __pyx_n_s_missing __pyx_mstate_global->__pyx_n_s_missing -#define __pyx_n_s_missing_keys __pyx_mstate_global->__pyx_n_s_missing_keys -#define __pyx_n_s_module __pyx_mstate_global->__pyx_n_s_module -#define __pyx_n_s_mro_entries __pyx_mstate_global->__pyx_n_s_mro_entries -#define __pyx_n_s_msg __pyx_mstate_global->__pyx_n_s_msg -#define __pyx_n_s_n __pyx_mstate_global->__pyx_n_s_n -#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name -#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 -#define __pyx_n_s_nan __pyx_mstate_global->__pyx_n_s_nan -#define __pyx_n_s_nbdev __pyx_mstate_global->__pyx_n_s_nbdev -#define __pyx_n_s_nbdevdn __pyx_mstate_global->__pyx_n_s_nbdevdn -#define __pyx_n_s_nbdevup __pyx_mstate_global->__pyx_n_s_nbdevup -#define __pyx_n_s_no_existing_input_arrays __pyx_mstate_global->__pyx_n_s_no_existing_input_arrays -#define __pyx_n_s_num_inputs __pyx_mstate_global->__pyx_n_s_num_inputs -#define __pyx_n_s_num_opt_inputs __pyx_mstate_global->__pyx_n_s_num_opt_inputs -#define __pyx_n_s_num_outputs __pyx_mstate_global->__pyx_n_s_num_outputs -#define __pyx_n_s_numpy __pyx_mstate_global->__pyx_n_s_numpy -#define __pyx_kp_s_numpy_core_multiarray_failed_to __pyx_mstate_global->__pyx_kp_s_numpy_core_multiarray_failed_to -#define __pyx_kp_s_numpy_core_umath_failed_to_impor __pyx_mstate_global->__pyx_kp_s_numpy_core_umath_failed_to_impor -#define __pyx_n_s_object __pyx_mstate_global->__pyx_n_s_object -#define __pyx_n_s_offsetonreverse __pyx_mstate_global->__pyx_n_s_offsetonreverse -#define __pyx_n_s_open __pyx_mstate_global->__pyx_n_s_open -#define __pyx_n_s_openInterest __pyx_mstate_global->__pyx_n_s_openInterest -#define __pyx_n_s_open_data __pyx_mstate_global->__pyx_n_s_open_data -#define __pyx_n_s_optIn __pyx_mstate_global->__pyx_n_s_optIn -#define __pyx_n_s_opt_input __pyx_mstate_global->__pyx_n_s_opt_input -#define __pyx_n_s_opt_input_values __pyx_mstate_global->__pyx_n_s_opt_input_values -#define __pyx_n_s_opt_inputs __pyx_mstate_global->__pyx_n_s_opt_inputs -#define __pyx_n_s_ordereddict __pyx_mstate_global->__pyx_n_s_ordereddict -#define __pyx_n_s_out __pyx_mstate_global->__pyx_n_s_out -#define __pyx_n_s_outaroondown __pyx_mstate_global->__pyx_n_s_outaroondown -#define __pyx_n_s_outaroonup __pyx_mstate_global->__pyx_n_s_outaroonup -#define __pyx_n_s_outbegidx __pyx_mstate_global->__pyx_n_s_outbegidx -#define __pyx_n_s_outfama __pyx_mstate_global->__pyx_n_s_outfama -#define __pyx_n_s_outfastd __pyx_mstate_global->__pyx_n_s_outfastd -#define __pyx_n_s_outfastk __pyx_mstate_global->__pyx_n_s_outfastk -#define __pyx_n_s_outinphase __pyx_mstate_global->__pyx_n_s_outinphase -#define __pyx_n_s_outinteger __pyx_mstate_global->__pyx_n_s_outinteger -#define __pyx_n_s_outinteger_data __pyx_mstate_global->__pyx_n_s_outinteger_data -#define __pyx_n_s_outleadsine __pyx_mstate_global->__pyx_n_s_outleadsine -#define __pyx_n_s_outmacd __pyx_mstate_global->__pyx_n_s_outmacd -#define __pyx_n_s_outmacdhist __pyx_mstate_global->__pyx_n_s_outmacdhist -#define __pyx_n_s_outmacdsignal __pyx_mstate_global->__pyx_n_s_outmacdsignal -#define __pyx_n_s_outmama __pyx_mstate_global->__pyx_n_s_outmama -#define __pyx_n_s_outmax __pyx_mstate_global->__pyx_n_s_outmax -#define __pyx_n_s_outmaxidx __pyx_mstate_global->__pyx_n_s_outmaxidx -#define __pyx_n_s_outmaxidx_data __pyx_mstate_global->__pyx_n_s_outmaxidx_data -#define __pyx_n_s_outmin __pyx_mstate_global->__pyx_n_s_outmin -#define __pyx_n_s_outminidx __pyx_mstate_global->__pyx_n_s_outminidx -#define __pyx_n_s_outminidx_data __pyx_mstate_global->__pyx_n_s_outminidx_data -#define __pyx_n_s_outnbelement __pyx_mstate_global->__pyx_n_s_outnbelement -#define __pyx_n_s_output __pyx_mstate_global->__pyx_n_s_output -#define __pyx_n_s_output_flags __pyx_mstate_global->__pyx_n_s_output_flags -#define __pyx_n_s_output_name __pyx_mstate_global->__pyx_n_s_output_name -#define __pyx_n_s_output_names __pyx_mstate_global->__pyx_n_s_output_names -#define __pyx_n_s_outputs __pyx_mstate_global->__pyx_n_s_outputs -#define __pyx_n_s_outputs_valid __pyx_mstate_global->__pyx_n_s_outputs_valid -#define __pyx_n_s_outquadrature __pyx_mstate_global->__pyx_n_s_outquadrature -#define __pyx_n_s_outreal __pyx_mstate_global->__pyx_n_s_outreal -#define __pyx_n_s_outreallowerband __pyx_mstate_global->__pyx_n_s_outreallowerband -#define __pyx_n_s_outrealmiddleband __pyx_mstate_global->__pyx_n_s_outrealmiddleband -#define __pyx_n_s_outrealupperband __pyx_mstate_global->__pyx_n_s_outrealupperband -#define __pyx_n_s_outsine __pyx_mstate_global->__pyx_n_s_outsine -#define __pyx_n_s_outslowd __pyx_mstate_global->__pyx_n_s_outslowd -#define __pyx_n_s_outslowk __pyx_mstate_global->__pyx_n_s_outslowk -#define __pyx_n_s_pandas __pyx_mstate_global->__pyx_n_s_pandas -#define __pyx_n_s_param __pyx_mstate_global->__pyx_n_s_param -#define __pyx_n_s_param_name __pyx_mstate_global->__pyx_n_s_param_name -#define __pyx_n_s_parameters __pyx_mstate_global->__pyx_n_s_parameters -#define __pyx_n_s_params __pyx_mstate_global->__pyx_n_s_params -#define __pyx_n_s_penetration __pyx_mstate_global->__pyx_n_s_penetration -#define __pyx_n_s_period __pyx_mstate_global->__pyx_n_s_period -#define __pyx_n_s_periods __pyx_mstate_global->__pyx_n_s_periods -#define __pyx_n_s_periods_data __pyx_mstate_global->__pyx_n_s_periods_data -#define __pyx_n_s_polars __pyx_mstate_global->__pyx_n_s_polars -#define __pyx_n_s_pop __pyx_mstate_global->__pyx_n_s_pop -#define __pyx_n_s_prepare __pyx_mstate_global->__pyx_n_s_prepare -#define __pyx_n_s_price __pyx_mstate_global->__pyx_n_s_price -#define __pyx_n_s_price0 __pyx_mstate_global->__pyx_n_s_price0 -#define __pyx_n_s_price1 __pyx_mstate_global->__pyx_n_s_price1 -#define __pyx_n_s_price_series __pyx_mstate_global->__pyx_n_s_price_series -#define __pyx_n_s_price_series_name_values __pyx_mstate_global->__pyx_n_s_price_series_name_values -#define __pyx_n_s_prices __pyx_mstate_global->__pyx_n_s_prices -#define __pyx_n_s_property __pyx_mstate_global->__pyx_n_s_property -#define __pyx_n_s_qualname __pyx_mstate_global->__pyx_n_s_qualname -#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range -#define __pyx_n_s_rangetype __pyx_mstate_global->__pyx_n_s_rangetype -#define __pyx_n_s_real __pyx_mstate_global->__pyx_n_s_real -#define __pyx_n_s_real0 __pyx_mstate_global->__pyx_n_s_real0 -#define __pyx_n_s_real0_data __pyx_mstate_global->__pyx_n_s_real0_data -#define __pyx_n_s_real1 __pyx_mstate_global->__pyx_n_s_real1 -#define __pyx_n_s_real1_data __pyx_mstate_global->__pyx_n_s_real1_data -#define __pyx_n_s_real_data __pyx_mstate_global->__pyx_n_s_real_data -#define __pyx_n_s_replace __pyx_mstate_global->__pyx_n_s_replace -#define __pyx_n_s_repr __pyx_mstate_global->__pyx_n_s_repr -#define __pyx_n_s_results __pyx_mstate_global->__pyx_n_s_results -#define __pyx_n_s_ret __pyx_mstate_global->__pyx_n_s_ret -#define __pyx_n_s_retCode __pyx_mstate_global->__pyx_n_s_retCode -#define __pyx_n_s_ret_code __pyx_mstate_global->__pyx_n_s_ret_code -#define __pyx_n_s_run __pyx_mstate_global->__pyx_n_s_run -#define __pyx_n_s_s __pyx_mstate_global->__pyx_n_s_s -#define __pyx_kp_s_s_2 __pyx_mstate_global->__pyx_kp_s_s_2 -#define __pyx_kp_s_s_3 __pyx_mstate_global->__pyx_kp_s_s_3 -#define __pyx_kp_s_s_4 __pyx_mstate_global->__pyx_kp_s_s_4 -#define __pyx_kp_s_s_function_failed_with_error_co __pyx_mstate_global->__pyx_kp_s_s_function_failed_with_error_co -#define __pyx_kp_s_s_s __pyx_mstate_global->__pyx_kp_s_s_s -#define __pyx_kp_s_s_s_2 __pyx_mstate_global->__pyx_kp_s_s_s_2 -#define __pyx_n_s_schema __pyx_mstate_global->__pyx_n_s_schema -#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self -#define __pyx_n_s_series __pyx_mstate_global->__pyx_n_s_series -#define __pyx_n_s_set_function_args __pyx_mstate_global->__pyx_n_s_set_function_args -#define __pyx_n_s_set_input_arrays __pyx_mstate_global->__pyx_n_s_set_input_arrays -#define __pyx_n_s_set_input_names __pyx_mstate_global->__pyx_n_s_set_input_names -#define __pyx_n_s_set_name __pyx_mstate_global->__pyx_n_s_set_name -#define __pyx_n_s_set_parameters __pyx_mstate_global->__pyx_n_s_set_parameters -#define __pyx_n_s_settingtype __pyx_mstate_global->__pyx_n_s_settingtype -#define __pyx_n_s_signalmatype __pyx_mstate_global->__pyx_n_s_signalmatype -#define __pyx_n_s_signalperiod __pyx_mstate_global->__pyx_n_s_signalperiod -#define __pyx_n_s_skip_first __pyx_mstate_global->__pyx_n_s_skip_first -#define __pyx_n_s_slowd_matype __pyx_mstate_global->__pyx_n_s_slowd_matype -#define __pyx_n_s_slowd_period __pyx_mstate_global->__pyx_n_s_slowd_period -#define __pyx_n_s_slowk_matype __pyx_mstate_global->__pyx_n_s_slowk_matype -#define __pyx_n_s_slowk_period __pyx_mstate_global->__pyx_n_s_slowk_period -#define __pyx_n_s_slowlimit __pyx_mstate_global->__pyx_n_s_slowlimit -#define __pyx_n_s_slowmatype __pyx_mstate_global->__pyx_n_s_slowmatype -#define __pyx_n_s_slowperiod __pyx_mstate_global->__pyx_n_s_slowperiod -#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec -#define __pyx_n_s_startvalue __pyx_mstate_global->__pyx_n_s_startvalue -#define __pyx_n_s_str __pyx_mstate_global->__pyx_n_s_str -#define __pyx_n_s_str2bytes __pyx_mstate_global->__pyx_n_s_str2bytes -#define __pyx_n_s_stream_ACOS __pyx_mstate_global->__pyx_n_s_stream_ACOS -#define __pyx_n_s_stream_AD __pyx_mstate_global->__pyx_n_s_stream_AD -#define __pyx_n_s_stream_ADD __pyx_mstate_global->__pyx_n_s_stream_ADD -#define __pyx_n_s_stream_ADOSC __pyx_mstate_global->__pyx_n_s_stream_ADOSC -#define __pyx_n_s_stream_ADX __pyx_mstate_global->__pyx_n_s_stream_ADX -#define __pyx_n_s_stream_ADXR __pyx_mstate_global->__pyx_n_s_stream_ADXR -#define __pyx_n_s_stream_APO __pyx_mstate_global->__pyx_n_s_stream_APO -#define __pyx_n_s_stream_AROON __pyx_mstate_global->__pyx_n_s_stream_AROON -#define __pyx_n_s_stream_AROONOSC __pyx_mstate_global->__pyx_n_s_stream_AROONOSC -#define __pyx_n_s_stream_ASIN __pyx_mstate_global->__pyx_n_s_stream_ASIN -#define __pyx_n_s_stream_ATAN __pyx_mstate_global->__pyx_n_s_stream_ATAN -#define __pyx_n_s_stream_ATR __pyx_mstate_global->__pyx_n_s_stream_ATR -#define __pyx_n_s_stream_AVGPRICE __pyx_mstate_global->__pyx_n_s_stream_AVGPRICE -#define __pyx_n_s_stream_BBANDS __pyx_mstate_global->__pyx_n_s_stream_BBANDS -#define __pyx_n_s_stream_BETA __pyx_mstate_global->__pyx_n_s_stream_BETA -#define __pyx_n_s_stream_BOP __pyx_mstate_global->__pyx_n_s_stream_BOP -#define __pyx_n_s_stream_CCI __pyx_mstate_global->__pyx_n_s_stream_CCI -#define __pyx_n_s_stream_CDL2CROWS __pyx_mstate_global->__pyx_n_s_stream_CDL2CROWS -#define __pyx_n_s_stream_CDL3BLACKCROWS __pyx_mstate_global->__pyx_n_s_stream_CDL3BLACKCROWS -#define __pyx_n_s_stream_CDL3INSIDE __pyx_mstate_global->__pyx_n_s_stream_CDL3INSIDE -#define __pyx_n_s_stream_CDL3LINESTRIKE __pyx_mstate_global->__pyx_n_s_stream_CDL3LINESTRIKE -#define __pyx_n_s_stream_CDL3OUTSIDE __pyx_mstate_global->__pyx_n_s_stream_CDL3OUTSIDE -#define __pyx_n_s_stream_CDL3STARSINSOUTH __pyx_mstate_global->__pyx_n_s_stream_CDL3STARSINSOUTH -#define __pyx_n_s_stream_CDL3WHITESOLDIERS __pyx_mstate_global->__pyx_n_s_stream_CDL3WHITESOLDIERS -#define __pyx_n_s_stream_CDLABANDONEDBABY __pyx_mstate_global->__pyx_n_s_stream_CDLABANDONEDBABY -#define __pyx_n_s_stream_CDLADVANCEBLOCK __pyx_mstate_global->__pyx_n_s_stream_CDLADVANCEBLOCK -#define __pyx_n_s_stream_CDLBELTHOLD __pyx_mstate_global->__pyx_n_s_stream_CDLBELTHOLD -#define __pyx_n_s_stream_CDLBREAKAWAY __pyx_mstate_global->__pyx_n_s_stream_CDLBREAKAWAY -#define __pyx_n_s_stream_CDLCLOSINGMARUBOZU __pyx_mstate_global->__pyx_n_s_stream_CDLCLOSINGMARUBOZU -#define __pyx_n_s_stream_CDLCONCEALBABYSWALL __pyx_mstate_global->__pyx_n_s_stream_CDLCONCEALBABYSWALL -#define __pyx_n_s_stream_CDLCOUNTERATTACK __pyx_mstate_global->__pyx_n_s_stream_CDLCOUNTERATTACK -#define __pyx_n_s_stream_CDLDARKCLOUDCOVER __pyx_mstate_global->__pyx_n_s_stream_CDLDARKCLOUDCOVER -#define __pyx_n_s_stream_CDLDOJI __pyx_mstate_global->__pyx_n_s_stream_CDLDOJI -#define __pyx_n_s_stream_CDLDOJISTAR __pyx_mstate_global->__pyx_n_s_stream_CDLDOJISTAR -#define __pyx_n_s_stream_CDLDRAGONFLYDOJI __pyx_mstate_global->__pyx_n_s_stream_CDLDRAGONFLYDOJI -#define __pyx_n_s_stream_CDLENGULFING __pyx_mstate_global->__pyx_n_s_stream_CDLENGULFING -#define __pyx_n_s_stream_CDLEVENINGDOJISTAR __pyx_mstate_global->__pyx_n_s_stream_CDLEVENINGDOJISTAR -#define __pyx_n_s_stream_CDLEVENINGSTAR __pyx_mstate_global->__pyx_n_s_stream_CDLEVENINGSTAR -#define __pyx_n_s_stream_CDLGAPSIDESIDEWHITE __pyx_mstate_global->__pyx_n_s_stream_CDLGAPSIDESIDEWHITE -#define __pyx_n_s_stream_CDLGRAVESTONEDOJI __pyx_mstate_global->__pyx_n_s_stream_CDLGRAVESTONEDOJI -#define __pyx_n_s_stream_CDLHAMMER __pyx_mstate_global->__pyx_n_s_stream_CDLHAMMER -#define __pyx_n_s_stream_CDLHANGINGMAN __pyx_mstate_global->__pyx_n_s_stream_CDLHANGINGMAN -#define __pyx_n_s_stream_CDLHARAMI __pyx_mstate_global->__pyx_n_s_stream_CDLHARAMI -#define __pyx_n_s_stream_CDLHARAMICROSS __pyx_mstate_global->__pyx_n_s_stream_CDLHARAMICROSS -#define __pyx_n_s_stream_CDLHIGHWAVE __pyx_mstate_global->__pyx_n_s_stream_CDLHIGHWAVE -#define __pyx_n_s_stream_CDLHIKKAKE __pyx_mstate_global->__pyx_n_s_stream_CDLHIKKAKE -#define __pyx_n_s_stream_CDLHIKKAKEMOD __pyx_mstate_global->__pyx_n_s_stream_CDLHIKKAKEMOD -#define __pyx_n_s_stream_CDLHOMINGPIGEON __pyx_mstate_global->__pyx_n_s_stream_CDLHOMINGPIGEON -#define __pyx_n_s_stream_CDLIDENTICAL3CROWS __pyx_mstate_global->__pyx_n_s_stream_CDLIDENTICAL3CROWS -#define __pyx_n_s_stream_CDLINNECK __pyx_mstate_global->__pyx_n_s_stream_CDLINNECK -#define __pyx_n_s_stream_CDLINVERTEDHAMMER __pyx_mstate_global->__pyx_n_s_stream_CDLINVERTEDHAMMER -#define __pyx_n_s_stream_CDLKICKING __pyx_mstate_global->__pyx_n_s_stream_CDLKICKING -#define __pyx_n_s_stream_CDLKICKINGBYLENGTH __pyx_mstate_global->__pyx_n_s_stream_CDLKICKINGBYLENGTH -#define __pyx_n_s_stream_CDLLADDERBOTTOM __pyx_mstate_global->__pyx_n_s_stream_CDLLADDERBOTTOM -#define __pyx_n_s_stream_CDLLONGLEGGEDDOJI __pyx_mstate_global->__pyx_n_s_stream_CDLLONGLEGGEDDOJI -#define __pyx_n_s_stream_CDLLONGLINE __pyx_mstate_global->__pyx_n_s_stream_CDLLONGLINE -#define __pyx_n_s_stream_CDLMARUBOZU __pyx_mstate_global->__pyx_n_s_stream_CDLMARUBOZU -#define __pyx_n_s_stream_CDLMATCHINGLOW __pyx_mstate_global->__pyx_n_s_stream_CDLMATCHINGLOW -#define __pyx_n_s_stream_CDLMATHOLD __pyx_mstate_global->__pyx_n_s_stream_CDLMATHOLD -#define __pyx_n_s_stream_CDLMORNINGDOJISTAR __pyx_mstate_global->__pyx_n_s_stream_CDLMORNINGDOJISTAR -#define __pyx_n_s_stream_CDLMORNINGSTAR __pyx_mstate_global->__pyx_n_s_stream_CDLMORNINGSTAR -#define __pyx_n_s_stream_CDLONNECK __pyx_mstate_global->__pyx_n_s_stream_CDLONNECK -#define __pyx_n_s_stream_CDLPIERCING __pyx_mstate_global->__pyx_n_s_stream_CDLPIERCING -#define __pyx_n_s_stream_CDLRICKSHAWMAN __pyx_mstate_global->__pyx_n_s_stream_CDLRICKSHAWMAN -#define __pyx_n_s_stream_CDLRISEFALL3METHODS __pyx_mstate_global->__pyx_n_s_stream_CDLRISEFALL3METHODS -#define __pyx_n_s_stream_CDLSEPARATINGLINES __pyx_mstate_global->__pyx_n_s_stream_CDLSEPARATINGLINES -#define __pyx_n_s_stream_CDLSHOOTINGSTAR __pyx_mstate_global->__pyx_n_s_stream_CDLSHOOTINGSTAR -#define __pyx_n_s_stream_CDLSHORTLINE __pyx_mstate_global->__pyx_n_s_stream_CDLSHORTLINE -#define __pyx_n_s_stream_CDLSPINNINGTOP __pyx_mstate_global->__pyx_n_s_stream_CDLSPINNINGTOP -#define __pyx_n_s_stream_CDLSTALLEDPATTERN __pyx_mstate_global->__pyx_n_s_stream_CDLSTALLEDPATTERN -#define __pyx_n_s_stream_CDLSTICKSANDWICH __pyx_mstate_global->__pyx_n_s_stream_CDLSTICKSANDWICH -#define __pyx_n_s_stream_CDLTAKURI __pyx_mstate_global->__pyx_n_s_stream_CDLTAKURI -#define __pyx_n_s_stream_CDLTASUKIGAP __pyx_mstate_global->__pyx_n_s_stream_CDLTASUKIGAP -#define __pyx_n_s_stream_CDLTHRUSTING __pyx_mstate_global->__pyx_n_s_stream_CDLTHRUSTING -#define __pyx_n_s_stream_CDLTRISTAR __pyx_mstate_global->__pyx_n_s_stream_CDLTRISTAR -#define __pyx_n_s_stream_CDLUNIQUE3RIVER __pyx_mstate_global->__pyx_n_s_stream_CDLUNIQUE3RIVER -#define __pyx_n_s_stream_CDLUPSIDEGAP2CROWS __pyx_mstate_global->__pyx_n_s_stream_CDLUPSIDEGAP2CROWS -#define __pyx_n_s_stream_CDLXSIDEGAP3METHODS __pyx_mstate_global->__pyx_n_s_stream_CDLXSIDEGAP3METHODS -#define __pyx_n_s_stream_CEIL __pyx_mstate_global->__pyx_n_s_stream_CEIL -#define __pyx_n_s_stream_CMO __pyx_mstate_global->__pyx_n_s_stream_CMO -#define __pyx_n_s_stream_CORREL __pyx_mstate_global->__pyx_n_s_stream_CORREL -#define __pyx_n_s_stream_COS __pyx_mstate_global->__pyx_n_s_stream_COS -#define __pyx_n_s_stream_COSH __pyx_mstate_global->__pyx_n_s_stream_COSH -#define __pyx_n_s_stream_DEMA __pyx_mstate_global->__pyx_n_s_stream_DEMA -#define __pyx_n_s_stream_DIV __pyx_mstate_global->__pyx_n_s_stream_DIV -#define __pyx_n_s_stream_DX __pyx_mstate_global->__pyx_n_s_stream_DX -#define __pyx_n_s_stream_EMA __pyx_mstate_global->__pyx_n_s_stream_EMA -#define __pyx_n_s_stream_EXP __pyx_mstate_global->__pyx_n_s_stream_EXP -#define __pyx_n_s_stream_FLOOR __pyx_mstate_global->__pyx_n_s_stream_FLOOR -#define __pyx_n_s_stream_HT_DCPERIOD __pyx_mstate_global->__pyx_n_s_stream_HT_DCPERIOD -#define __pyx_n_s_stream_HT_DCPHASE __pyx_mstate_global->__pyx_n_s_stream_HT_DCPHASE -#define __pyx_n_s_stream_HT_PHASOR __pyx_mstate_global->__pyx_n_s_stream_HT_PHASOR -#define __pyx_n_s_stream_HT_SINE __pyx_mstate_global->__pyx_n_s_stream_HT_SINE -#define __pyx_n_s_stream_HT_TRENDLINE __pyx_mstate_global->__pyx_n_s_stream_HT_TRENDLINE -#define __pyx_n_s_stream_HT_TRENDMODE __pyx_mstate_global->__pyx_n_s_stream_HT_TRENDMODE -#define __pyx_n_s_stream_KAMA __pyx_mstate_global->__pyx_n_s_stream_KAMA -#define __pyx_n_s_stream_LINEARREG __pyx_mstate_global->__pyx_n_s_stream_LINEARREG -#define __pyx_n_s_stream_LINEARREG_ANGLE __pyx_mstate_global->__pyx_n_s_stream_LINEARREG_ANGLE -#define __pyx_n_s_stream_LINEARREG_INTERCEPT __pyx_mstate_global->__pyx_n_s_stream_LINEARREG_INTERCEPT -#define __pyx_n_s_stream_LINEARREG_SLOPE __pyx_mstate_global->__pyx_n_s_stream_LINEARREG_SLOPE -#define __pyx_n_s_stream_LN __pyx_mstate_global->__pyx_n_s_stream_LN -#define __pyx_n_s_stream_LOG10 __pyx_mstate_global->__pyx_n_s_stream_LOG10 -#define __pyx_n_s_stream_MA __pyx_mstate_global->__pyx_n_s_stream_MA -#define __pyx_n_s_stream_MACD __pyx_mstate_global->__pyx_n_s_stream_MACD -#define __pyx_n_s_stream_MACDEXT __pyx_mstate_global->__pyx_n_s_stream_MACDEXT -#define __pyx_n_s_stream_MACDFIX __pyx_mstate_global->__pyx_n_s_stream_MACDFIX -#define __pyx_n_s_stream_MAMA __pyx_mstate_global->__pyx_n_s_stream_MAMA -#define __pyx_n_s_stream_MAVP __pyx_mstate_global->__pyx_n_s_stream_MAVP -#define __pyx_n_s_stream_MAX __pyx_mstate_global->__pyx_n_s_stream_MAX -#define __pyx_n_s_stream_MAXINDEX __pyx_mstate_global->__pyx_n_s_stream_MAXINDEX -#define __pyx_n_s_stream_MEDPRICE __pyx_mstate_global->__pyx_n_s_stream_MEDPRICE -#define __pyx_n_s_stream_MFI __pyx_mstate_global->__pyx_n_s_stream_MFI -#define __pyx_n_s_stream_MIDPOINT __pyx_mstate_global->__pyx_n_s_stream_MIDPOINT -#define __pyx_n_s_stream_MIDPRICE __pyx_mstate_global->__pyx_n_s_stream_MIDPRICE -#define __pyx_n_s_stream_MIN __pyx_mstate_global->__pyx_n_s_stream_MIN -#define __pyx_n_s_stream_MININDEX __pyx_mstate_global->__pyx_n_s_stream_MININDEX -#define __pyx_n_s_stream_MINMAX __pyx_mstate_global->__pyx_n_s_stream_MINMAX -#define __pyx_n_s_stream_MINMAXINDEX __pyx_mstate_global->__pyx_n_s_stream_MINMAXINDEX -#define __pyx_n_s_stream_MINUS_DI __pyx_mstate_global->__pyx_n_s_stream_MINUS_DI -#define __pyx_n_s_stream_MINUS_DM __pyx_mstate_global->__pyx_n_s_stream_MINUS_DM -#define __pyx_n_s_stream_MOM __pyx_mstate_global->__pyx_n_s_stream_MOM -#define __pyx_n_s_stream_MULT __pyx_mstate_global->__pyx_n_s_stream_MULT -#define __pyx_n_s_stream_NATR __pyx_mstate_global->__pyx_n_s_stream_NATR -#define __pyx_n_s_stream_OBV __pyx_mstate_global->__pyx_n_s_stream_OBV -#define __pyx_n_s_stream_PLUS_DI __pyx_mstate_global->__pyx_n_s_stream_PLUS_DI -#define __pyx_n_s_stream_PLUS_DM __pyx_mstate_global->__pyx_n_s_stream_PLUS_DM -#define __pyx_n_s_stream_PPO __pyx_mstate_global->__pyx_n_s_stream_PPO -#define __pyx_n_s_stream_ROC __pyx_mstate_global->__pyx_n_s_stream_ROC -#define __pyx_n_s_stream_ROCP __pyx_mstate_global->__pyx_n_s_stream_ROCP -#define __pyx_n_s_stream_ROCR __pyx_mstate_global->__pyx_n_s_stream_ROCR -#define __pyx_n_s_stream_ROCR100 __pyx_mstate_global->__pyx_n_s_stream_ROCR100 -#define __pyx_n_s_stream_RSI __pyx_mstate_global->__pyx_n_s_stream_RSI -#define __pyx_n_s_stream_SAR __pyx_mstate_global->__pyx_n_s_stream_SAR -#define __pyx_n_s_stream_SAREXT __pyx_mstate_global->__pyx_n_s_stream_SAREXT -#define __pyx_n_s_stream_SIN __pyx_mstate_global->__pyx_n_s_stream_SIN -#define __pyx_n_s_stream_SINH __pyx_mstate_global->__pyx_n_s_stream_SINH -#define __pyx_n_s_stream_SMA __pyx_mstate_global->__pyx_n_s_stream_SMA -#define __pyx_n_s_stream_SQRT __pyx_mstate_global->__pyx_n_s_stream_SQRT -#define __pyx_n_s_stream_STDDEV __pyx_mstate_global->__pyx_n_s_stream_STDDEV -#define __pyx_n_s_stream_STOCH __pyx_mstate_global->__pyx_n_s_stream_STOCH -#define __pyx_n_s_stream_STOCHF __pyx_mstate_global->__pyx_n_s_stream_STOCHF -#define __pyx_n_s_stream_STOCHRSI __pyx_mstate_global->__pyx_n_s_stream_STOCHRSI -#define __pyx_n_s_stream_SUB __pyx_mstate_global->__pyx_n_s_stream_SUB -#define __pyx_n_s_stream_SUM __pyx_mstate_global->__pyx_n_s_stream_SUM -#define __pyx_n_s_stream_T3 __pyx_mstate_global->__pyx_n_s_stream_T3 -#define __pyx_n_s_stream_TAN __pyx_mstate_global->__pyx_n_s_stream_TAN -#define __pyx_n_s_stream_TANH __pyx_mstate_global->__pyx_n_s_stream_TANH -#define __pyx_n_s_stream_TEMA __pyx_mstate_global->__pyx_n_s_stream_TEMA -#define __pyx_n_s_stream_TRANGE __pyx_mstate_global->__pyx_n_s_stream_TRANGE -#define __pyx_n_s_stream_TRIMA __pyx_mstate_global->__pyx_n_s_stream_TRIMA -#define __pyx_n_s_stream_TRIX __pyx_mstate_global->__pyx_n_s_stream_TRIX -#define __pyx_n_s_stream_TSF __pyx_mstate_global->__pyx_n_s_stream_TSF -#define __pyx_n_s_stream_TYPPRICE __pyx_mstate_global->__pyx_n_s_stream_TYPPRICE -#define __pyx_n_s_stream_ULTOSC __pyx_mstate_global->__pyx_n_s_stream_ULTOSC -#define __pyx_n_s_stream_VAR __pyx_mstate_global->__pyx_n_s_stream_VAR -#define __pyx_n_s_stream_WCLPRICE __pyx_mstate_global->__pyx_n_s_stream_WCLPRICE -#define __pyx_n_s_stream_WILLR __pyx_mstate_global->__pyx_n_s_stream_WILLR -#define __pyx_n_s_stream_WMA __pyx_mstate_global->__pyx_n_s_stream_WMA -#define __pyx_kp_s_stream__s __pyx_mstate_global->__pyx_kp_s_stream__s -#define __pyx_n_s_super __pyx_mstate_global->__pyx_n_s_super -#define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys -#define __pyx_n_s_ta_check_success __pyx_mstate_global->__pyx_n_s_ta_check_success -#define __pyx_n_s_ta_func_unst_ids __pyx_mstate_global->__pyx_n_s_ta_func_unst_ids -#define __pyx_n_s_ta_getFuncInfo __pyx_mstate_global->__pyx_n_s_ta_getFuncInfo -#define __pyx_n_s_ta_getFuncTable __pyx_mstate_global->__pyx_n_s_ta_getFuncTable -#define __pyx_n_s_ta_getGroupTable __pyx_mstate_global->__pyx_n_s_ta_getGroupTable -#define __pyx_n_s_ta_getInputParameterInfo __pyx_mstate_global->__pyx_n_s_ta_getInputParameterInfo -#define __pyx_n_s_ta_getOptInputParameterInfo __pyx_mstate_global->__pyx_n_s_ta_getOptInputParameterInfo -#define __pyx_n_s_ta_getOutputParameterInfo __pyx_mstate_global->__pyx_n_s_ta_getOutputParameterInfo -#define __pyx_n_s_ta_get_compatibility __pyx_mstate_global->__pyx_n_s_ta_get_compatibility -#define __pyx_n_s_ta_get_unstable_period __pyx_mstate_global->__pyx_n_s_ta_get_unstable_period -#define __pyx_n_s_ta_initialize __pyx_mstate_global->__pyx_n_s_ta_initialize -#define __pyx_n_s_ta_restore_candle_default_setti __pyx_mstate_global->__pyx_n_s_ta_restore_candle_default_setti -#define __pyx_n_s_ta_set_candle_settings __pyx_mstate_global->__pyx_n_s_ta_set_candle_settings -#define __pyx_n_s_ta_set_compatibility __pyx_mstate_global->__pyx_n_s_ta_set_compatibility -#define __pyx_n_s_ta_set_unstable_period __pyx_mstate_global->__pyx_n_s_ta_set_unstable_period -#define __pyx_n_s_ta_shutdown __pyx_mstate_global->__pyx_n_s_ta_shutdown -#define __pyx_n_s_ta_version __pyx_mstate_global->__pyx_n_s_ta_version -#define __pyx_n_s_table __pyx_mstate_global->__pyx_n_s_table -#define __pyx_kp_s_talib__abstract_pxi __pyx_mstate_global->__pyx_kp_s_talib__abstract_pxi -#define __pyx_kp_s_talib__common_pxi __pyx_mstate_global->__pyx_kp_s_talib__common_pxi -#define __pyx_kp_s_talib__func_pxi __pyx_mstate_global->__pyx_kp_s_talib__func_pxi -#define __pyx_kp_s_talib__stream_pxi __pyx_mstate_global->__pyx_kp_s_talib__stream_pxi -#define __pyx_n_s_talib__ta_lib __pyx_mstate_global->__pyx_n_s_talib__ta_lib -#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test -#define __pyx_n_s_threading __pyx_mstate_global->__pyx_n_s_threading -#define __pyx_n_s_timeStamp __pyx_mstate_global->__pyx_n_s_timeStamp -#define __pyx_n_s_timeperiod __pyx_mstate_global->__pyx_n_s_timeperiod -#define __pyx_n_s_timeperiod1 __pyx_mstate_global->__pyx_n_s_timeperiod1 -#define __pyx_n_s_timeperiod2 __pyx_mstate_global->__pyx_n_s_timeperiod2 -#define __pyx_n_s_timeperiod3 __pyx_mstate_global->__pyx_n_s_timeperiod3 -#define __pyx_n_s_to_numpy __pyx_mstate_global->__pyx_n_s_to_numpy -#define __pyx_n_s_type __pyx_mstate_global->__pyx_n_s_type -#define __pyx_n_s_type_2 __pyx_mstate_global->__pyx_n_s_type_2 -#define __pyx_n_s_unicode __pyx_mstate_global->__pyx_n_s_unicode -#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update -#define __pyx_n_s_update_info __pyx_mstate_global->__pyx_n_s_update_info -#define __pyx_n_s_upper __pyx_mstate_global->__pyx_n_s_upper -#define __pyx_n_s_value __pyx_mstate_global->__pyx_n_s_value -#define __pyx_n_s_value_range __pyx_mstate_global->__pyx_n_s_value_range -#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values -#define __pyx_n_s_version __pyx_mstate_global->__pyx_n_s_version -#define __pyx_n_s_vfactor __pyx_mstate_global->__pyx_n_s_vfactor -#define __pyx_n_s_volume __pyx_mstate_global->__pyx_n_s_volume -#define __pyx_n_s_volume_data __pyx_mstate_global->__pyx_n_s_volume_data -#define __pyx_n_s_xrange __pyx_mstate_global->__pyx_n_s_xrange -#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 -#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 -#define __pyx_int_2 __pyx_mstate_global->__pyx_int_2 -#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3 -#define __pyx_int_4 __pyx_mstate_global->__pyx_int_4 -#define __pyx_int_8 __pyx_mstate_global->__pyx_int_8 -#define __pyx_int_9 __pyx_mstate_global->__pyx_int_9 -#define __pyx_int_12 __pyx_mstate_global->__pyx_int_12 -#define __pyx_int_16 __pyx_mstate_global->__pyx_int_16 -#define __pyx_int_32 __pyx_mstate_global->__pyx_int_32 -#define __pyx_int_64 __pyx_mstate_global->__pyx_int_64 -#define __pyx_int_128 __pyx_mstate_global->__pyx_int_128 -#define __pyx_int_256 __pyx_mstate_global->__pyx_int_256 -#define __pyx_int_512 __pyx_mstate_global->__pyx_int_512 -#define __pyx_int_1024 __pyx_mstate_global->__pyx_int_1024 -#define __pyx_int_2048 __pyx_mstate_global->__pyx_int_2048 -#define __pyx_int_4096 __pyx_mstate_global->__pyx_int_4096 -#define __pyx_int_16777216 __pyx_mstate_global->__pyx_int_16777216 -#define __pyx_int_67108864 __pyx_mstate_global->__pyx_int_67108864 -#define __pyx_int_134217728 __pyx_mstate_global->__pyx_int_134217728 -#define __pyx_int_268435456 __pyx_mstate_global->__pyx_int_268435456 -#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 -#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ -#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2 -#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 -#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 -#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5 -#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 -#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 -#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15 -#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 -#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19 -#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 -#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21 -#define __pyx_tuple__23 __pyx_mstate_global->__pyx_tuple__23 -#define __pyx_tuple__25 __pyx_mstate_global->__pyx_tuple__25 -#define __pyx_tuple__27 __pyx_mstate_global->__pyx_tuple__27 -#define __pyx_tuple__29 __pyx_mstate_global->__pyx_tuple__29 -#define __pyx_tuple__31 __pyx_mstate_global->__pyx_tuple__31 -#define __pyx_tuple__33 __pyx_mstate_global->__pyx_tuple__33 -#define __pyx_tuple__34 __pyx_mstate_global->__pyx_tuple__34 -#define __pyx_tuple__35 __pyx_mstate_global->__pyx_tuple__35 -#define __pyx_tuple__36 __pyx_mstate_global->__pyx_tuple__36 -#define __pyx_tuple__37 __pyx_mstate_global->__pyx_tuple__37 -#define __pyx_tuple__38 __pyx_mstate_global->__pyx_tuple__38 -#define __pyx_tuple__39 __pyx_mstate_global->__pyx_tuple__39 -#define __pyx_tuple__41 __pyx_mstate_global->__pyx_tuple__41 -#define __pyx_tuple__44 __pyx_mstate_global->__pyx_tuple__44 -#define __pyx_tuple__46 __pyx_mstate_global->__pyx_tuple__46 -#define __pyx_tuple__48 __pyx_mstate_global->__pyx_tuple__48 -#define __pyx_tuple__50 __pyx_mstate_global->__pyx_tuple__50 -#define __pyx_tuple__52 __pyx_mstate_global->__pyx_tuple__52 -#define __pyx_tuple__55 __pyx_mstate_global->__pyx_tuple__55 -#define __pyx_tuple__57 __pyx_mstate_global->__pyx_tuple__57 -#define __pyx_tuple__59 __pyx_mstate_global->__pyx_tuple__59 -#define __pyx_tuple__64 __pyx_mstate_global->__pyx_tuple__64 -#define __pyx_tuple__66 __pyx_mstate_global->__pyx_tuple__66 -#define __pyx_tuple__68 __pyx_mstate_global->__pyx_tuple__68 -#define __pyx_tuple__72 __pyx_mstate_global->__pyx_tuple__72 -#define __pyx_tuple__80 __pyx_mstate_global->__pyx_tuple__80 -#define __pyx_tuple__136 __pyx_mstate_global->__pyx_tuple__136 -#define __pyx_tuple__149 __pyx_mstate_global->__pyx_tuple__149 -#define __pyx_tuple__151 __pyx_mstate_global->__pyx_tuple__151 -#define __pyx_tuple__154 __pyx_mstate_global->__pyx_tuple__154 -#define __pyx_tuple__163 __pyx_mstate_global->__pyx_tuple__163 -#define __pyx_tuple__165 __pyx_mstate_global->__pyx_tuple__165 -#define __pyx_tuple__167 __pyx_mstate_global->__pyx_tuple__167 -#define __pyx_tuple__169 __pyx_mstate_global->__pyx_tuple__169 -#define __pyx_tuple__171 __pyx_mstate_global->__pyx_tuple__171 -#define __pyx_tuple__173 __pyx_mstate_global->__pyx_tuple__173 -#define __pyx_tuple__176 __pyx_mstate_global->__pyx_tuple__176 -#define __pyx_tuple__178 __pyx_mstate_global->__pyx_tuple__178 -#define __pyx_tuple__180 __pyx_mstate_global->__pyx_tuple__180 -#define __pyx_tuple__186 __pyx_mstate_global->__pyx_tuple__186 -#define __pyx_tuple__188 __pyx_mstate_global->__pyx_tuple__188 -#define __pyx_tuple__195 __pyx_mstate_global->__pyx_tuple__195 -#define __pyx_tuple__205 __pyx_mstate_global->__pyx_tuple__205 -#define __pyx_tuple__207 __pyx_mstate_global->__pyx_tuple__207 -#define __pyx_tuple__213 __pyx_mstate_global->__pyx_tuple__213 -#define __pyx_tuple__215 __pyx_mstate_global->__pyx_tuple__215 -#define __pyx_tuple__217 __pyx_mstate_global->__pyx_tuple__217 -#define __pyx_tuple__219 __pyx_mstate_global->__pyx_tuple__219 -#define __pyx_tuple__223 __pyx_mstate_global->__pyx_tuple__223 -#define __pyx_tuple__228 __pyx_mstate_global->__pyx_tuple__228 -#define __pyx_tuple__234 __pyx_mstate_global->__pyx_tuple__234 -#define __pyx_tuple__241 __pyx_mstate_global->__pyx_tuple__241 -#define __pyx_tuple__243 __pyx_mstate_global->__pyx_tuple__243 -#define __pyx_tuple__247 __pyx_mstate_global->__pyx_tuple__247 -#define __pyx_tuple__248 __pyx_mstate_global->__pyx_tuple__248 -#define __pyx_tuple__249 __pyx_mstate_global->__pyx_tuple__249 -#define __pyx_tuple__251 __pyx_mstate_global->__pyx_tuple__251 -#define __pyx_tuple__256 __pyx_mstate_global->__pyx_tuple__256 -#define __pyx_tuple__258 __pyx_mstate_global->__pyx_tuple__258 -#define __pyx_tuple__260 __pyx_mstate_global->__pyx_tuple__260 -#define __pyx_tuple__262 __pyx_mstate_global->__pyx_tuple__262 -#define __pyx_tuple__264 __pyx_mstate_global->__pyx_tuple__264 -#define __pyx_tuple__266 __pyx_mstate_global->__pyx_tuple__266 -#define __pyx_tuple__268 __pyx_mstate_global->__pyx_tuple__268 -#define __pyx_tuple__269 __pyx_mstate_global->__pyx_tuple__269 -#define __pyx_tuple__271 __pyx_mstate_global->__pyx_tuple__271 -#define __pyx_tuple__273 __pyx_mstate_global->__pyx_tuple__273 -#define __pyx_tuple__275 __pyx_mstate_global->__pyx_tuple__275 -#define __pyx_tuple__277 __pyx_mstate_global->__pyx_tuple__277 -#define __pyx_tuple__279 __pyx_mstate_global->__pyx_tuple__279 -#define __pyx_tuple__281 __pyx_mstate_global->__pyx_tuple__281 -#define __pyx_tuple__283 __pyx_mstate_global->__pyx_tuple__283 -#define __pyx_tuple__285 __pyx_mstate_global->__pyx_tuple__285 -#define __pyx_tuple__287 __pyx_mstate_global->__pyx_tuple__287 -#define __pyx_tuple__292 __pyx_mstate_global->__pyx_tuple__292 -#define __pyx_tuple__294 __pyx_mstate_global->__pyx_tuple__294 -#define __pyx_tuple__296 __pyx_mstate_global->__pyx_tuple__296 -#define __pyx_tuple__298 __pyx_mstate_global->__pyx_tuple__298 -#define __pyx_tuple__300 __pyx_mstate_global->__pyx_tuple__300 -#define __pyx_tuple__302 __pyx_mstate_global->__pyx_tuple__302 -#define __pyx_tuple__305 __pyx_mstate_global->__pyx_tuple__305 -#define __pyx_tuple__307 __pyx_mstate_global->__pyx_tuple__307 -#define __pyx_tuple__309 __pyx_mstate_global->__pyx_tuple__309 -#define __pyx_tuple__311 __pyx_mstate_global->__pyx_tuple__311 -#define __pyx_tuple__313 __pyx_mstate_global->__pyx_tuple__313 -#define __pyx_tuple__315 __pyx_mstate_global->__pyx_tuple__315 -#define __pyx_tuple__318 __pyx_mstate_global->__pyx_tuple__318 -#define __pyx_tuple__320 __pyx_mstate_global->__pyx_tuple__320 -#define __pyx_tuple__322 __pyx_mstate_global->__pyx_tuple__322 -#define __pyx_tuple__327 __pyx_mstate_global->__pyx_tuple__327 -#define __pyx_tuple__329 __pyx_mstate_global->__pyx_tuple__329 -#define __pyx_tuple__331 __pyx_mstate_global->__pyx_tuple__331 -#define __pyx_tuple__335 __pyx_mstate_global->__pyx_tuple__335 -#define __pyx_tuple__343 __pyx_mstate_global->__pyx_tuple__343 -#define __pyx_tuple__399 __pyx_mstate_global->__pyx_tuple__399 -#define __pyx_tuple__412 __pyx_mstate_global->__pyx_tuple__412 -#define __pyx_tuple__414 __pyx_mstate_global->__pyx_tuple__414 -#define __pyx_tuple__417 __pyx_mstate_global->__pyx_tuple__417 -#define __pyx_tuple__426 __pyx_mstate_global->__pyx_tuple__426 -#define __pyx_tuple__428 __pyx_mstate_global->__pyx_tuple__428 -#define __pyx_tuple__430 __pyx_mstate_global->__pyx_tuple__430 -#define __pyx_tuple__432 __pyx_mstate_global->__pyx_tuple__432 -#define __pyx_tuple__434 __pyx_mstate_global->__pyx_tuple__434 -#define __pyx_tuple__436 __pyx_mstate_global->__pyx_tuple__436 -#define __pyx_tuple__439 __pyx_mstate_global->__pyx_tuple__439 -#define __pyx_tuple__441 __pyx_mstate_global->__pyx_tuple__441 -#define __pyx_tuple__443 __pyx_mstate_global->__pyx_tuple__443 -#define __pyx_tuple__449 __pyx_mstate_global->__pyx_tuple__449 -#define __pyx_tuple__451 __pyx_mstate_global->__pyx_tuple__451 -#define __pyx_tuple__458 __pyx_mstate_global->__pyx_tuple__458 -#define __pyx_tuple__468 __pyx_mstate_global->__pyx_tuple__468 -#define __pyx_tuple__470 __pyx_mstate_global->__pyx_tuple__470 -#define __pyx_tuple__476 __pyx_mstate_global->__pyx_tuple__476 -#define __pyx_tuple__478 __pyx_mstate_global->__pyx_tuple__478 -#define __pyx_tuple__480 __pyx_mstate_global->__pyx_tuple__480 -#define __pyx_tuple__482 __pyx_mstate_global->__pyx_tuple__482 -#define __pyx_tuple__486 __pyx_mstate_global->__pyx_tuple__486 -#define __pyx_tuple__491 __pyx_mstate_global->__pyx_tuple__491 -#define __pyx_tuple__497 __pyx_mstate_global->__pyx_tuple__497 -#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 -#define __pyx_codeobj__16 __pyx_mstate_global->__pyx_codeobj__16 -#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 -#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 -#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24 -#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26 -#define __pyx_codeobj__28 __pyx_mstate_global->__pyx_codeobj__28 -#define __pyx_codeobj__30 __pyx_mstate_global->__pyx_codeobj__30 -#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32 -#define __pyx_codeobj__40 __pyx_mstate_global->__pyx_codeobj__40 -#define __pyx_codeobj__42 __pyx_mstate_global->__pyx_codeobj__42 -#define __pyx_codeobj__45 __pyx_mstate_global->__pyx_codeobj__45 -#define __pyx_codeobj__47 __pyx_mstate_global->__pyx_codeobj__47 -#define __pyx_codeobj__49 __pyx_mstate_global->__pyx_codeobj__49 -#define __pyx_codeobj__51 __pyx_mstate_global->__pyx_codeobj__51 -#define __pyx_codeobj__53 __pyx_mstate_global->__pyx_codeobj__53 -#define __pyx_codeobj__54 __pyx_mstate_global->__pyx_codeobj__54 -#define __pyx_codeobj__56 __pyx_mstate_global->__pyx_codeobj__56 -#define __pyx_codeobj__58 __pyx_mstate_global->__pyx_codeobj__58 -#define __pyx_codeobj__60 __pyx_mstate_global->__pyx_codeobj__60 -#define __pyx_codeobj__61 __pyx_mstate_global->__pyx_codeobj__61 -#define __pyx_codeobj__62 __pyx_mstate_global->__pyx_codeobj__62 -#define __pyx_codeobj__63 __pyx_mstate_global->__pyx_codeobj__63 -#define __pyx_codeobj__65 __pyx_mstate_global->__pyx_codeobj__65 -#define __pyx_codeobj__67 __pyx_mstate_global->__pyx_codeobj__67 -#define __pyx_codeobj__69 __pyx_mstate_global->__pyx_codeobj__69 -#define __pyx_codeobj__70 __pyx_mstate_global->__pyx_codeobj__70 -#define __pyx_codeobj__71 __pyx_mstate_global->__pyx_codeobj__71 -#define __pyx_codeobj__73 __pyx_mstate_global->__pyx_codeobj__73 -#define __pyx_codeobj__74 __pyx_mstate_global->__pyx_codeobj__74 -#define __pyx_codeobj__75 __pyx_mstate_global->__pyx_codeobj__75 -#define __pyx_codeobj__76 __pyx_mstate_global->__pyx_codeobj__76 -#define __pyx_codeobj__77 __pyx_mstate_global->__pyx_codeobj__77 -#define __pyx_codeobj__78 __pyx_mstate_global->__pyx_codeobj__78 -#define __pyx_codeobj__79 __pyx_mstate_global->__pyx_codeobj__79 -#define __pyx_codeobj__81 __pyx_mstate_global->__pyx_codeobj__81 -#define __pyx_codeobj__82 __pyx_mstate_global->__pyx_codeobj__82 -#define __pyx_codeobj__83 __pyx_mstate_global->__pyx_codeobj__83 -#define __pyx_codeobj__84 __pyx_mstate_global->__pyx_codeobj__84 -#define __pyx_codeobj__85 __pyx_mstate_global->__pyx_codeobj__85 -#define __pyx_codeobj__86 __pyx_mstate_global->__pyx_codeobj__86 -#define __pyx_codeobj__87 __pyx_mstate_global->__pyx_codeobj__87 -#define __pyx_codeobj__88 __pyx_mstate_global->__pyx_codeobj__88 -#define __pyx_codeobj__89 __pyx_mstate_global->__pyx_codeobj__89 -#define __pyx_codeobj__90 __pyx_mstate_global->__pyx_codeobj__90 -#define __pyx_codeobj__91 __pyx_mstate_global->__pyx_codeobj__91 -#define __pyx_codeobj__92 __pyx_mstate_global->__pyx_codeobj__92 -#define __pyx_codeobj__93 __pyx_mstate_global->__pyx_codeobj__93 -#define __pyx_codeobj__94 __pyx_mstate_global->__pyx_codeobj__94 -#define __pyx_codeobj__95 __pyx_mstate_global->__pyx_codeobj__95 -#define __pyx_codeobj__96 __pyx_mstate_global->__pyx_codeobj__96 -#define __pyx_codeobj__97 __pyx_mstate_global->__pyx_codeobj__97 -#define __pyx_codeobj__98 __pyx_mstate_global->__pyx_codeobj__98 -#define __pyx_codeobj__99 __pyx_mstate_global->__pyx_codeobj__99 -#define __pyx_codeobj__100 __pyx_mstate_global->__pyx_codeobj__100 -#define __pyx_codeobj__101 __pyx_mstate_global->__pyx_codeobj__101 -#define __pyx_codeobj__102 __pyx_mstate_global->__pyx_codeobj__102 -#define __pyx_codeobj__103 __pyx_mstate_global->__pyx_codeobj__103 -#define __pyx_codeobj__104 __pyx_mstate_global->__pyx_codeobj__104 -#define __pyx_codeobj__105 __pyx_mstate_global->__pyx_codeobj__105 -#define __pyx_codeobj__106 __pyx_mstate_global->__pyx_codeobj__106 -#define __pyx_codeobj__107 __pyx_mstate_global->__pyx_codeobj__107 -#define __pyx_codeobj__108 __pyx_mstate_global->__pyx_codeobj__108 -#define __pyx_codeobj__109 __pyx_mstate_global->__pyx_codeobj__109 -#define __pyx_codeobj__110 __pyx_mstate_global->__pyx_codeobj__110 -#define __pyx_codeobj__111 __pyx_mstate_global->__pyx_codeobj__111 -#define __pyx_codeobj__112 __pyx_mstate_global->__pyx_codeobj__112 -#define __pyx_codeobj__113 __pyx_mstate_global->__pyx_codeobj__113 -#define __pyx_codeobj__114 __pyx_mstate_global->__pyx_codeobj__114 -#define __pyx_codeobj__115 __pyx_mstate_global->__pyx_codeobj__115 -#define __pyx_codeobj__116 __pyx_mstate_global->__pyx_codeobj__116 -#define __pyx_codeobj__117 __pyx_mstate_global->__pyx_codeobj__117 -#define __pyx_codeobj__118 __pyx_mstate_global->__pyx_codeobj__118 -#define __pyx_codeobj__119 __pyx_mstate_global->__pyx_codeobj__119 -#define __pyx_codeobj__120 __pyx_mstate_global->__pyx_codeobj__120 -#define __pyx_codeobj__121 __pyx_mstate_global->__pyx_codeobj__121 -#define __pyx_codeobj__122 __pyx_mstate_global->__pyx_codeobj__122 -#define __pyx_codeobj__123 __pyx_mstate_global->__pyx_codeobj__123 -#define __pyx_codeobj__124 __pyx_mstate_global->__pyx_codeobj__124 -#define __pyx_codeobj__125 __pyx_mstate_global->__pyx_codeobj__125 -#define __pyx_codeobj__126 __pyx_mstate_global->__pyx_codeobj__126 -#define __pyx_codeobj__127 __pyx_mstate_global->__pyx_codeobj__127 -#define __pyx_codeobj__128 __pyx_mstate_global->__pyx_codeobj__128 -#define __pyx_codeobj__129 __pyx_mstate_global->__pyx_codeobj__129 -#define __pyx_codeobj__130 __pyx_mstate_global->__pyx_codeobj__130 -#define __pyx_codeobj__131 __pyx_mstate_global->__pyx_codeobj__131 -#define __pyx_codeobj__132 __pyx_mstate_global->__pyx_codeobj__132 -#define __pyx_codeobj__133 __pyx_mstate_global->__pyx_codeobj__133 -#define __pyx_codeobj__134 __pyx_mstate_global->__pyx_codeobj__134 -#define __pyx_codeobj__135 __pyx_mstate_global->__pyx_codeobj__135 -#define __pyx_codeobj__137 __pyx_mstate_global->__pyx_codeobj__137 -#define __pyx_codeobj__138 __pyx_mstate_global->__pyx_codeobj__138 -#define __pyx_codeobj__139 __pyx_mstate_global->__pyx_codeobj__139 -#define __pyx_codeobj__140 __pyx_mstate_global->__pyx_codeobj__140 -#define __pyx_codeobj__141 __pyx_mstate_global->__pyx_codeobj__141 -#define __pyx_codeobj__142 __pyx_mstate_global->__pyx_codeobj__142 -#define __pyx_codeobj__143 __pyx_mstate_global->__pyx_codeobj__143 -#define __pyx_codeobj__144 __pyx_mstate_global->__pyx_codeobj__144 -#define __pyx_codeobj__145 __pyx_mstate_global->__pyx_codeobj__145 -#define __pyx_codeobj__146 __pyx_mstate_global->__pyx_codeobj__146 -#define __pyx_codeobj__147 __pyx_mstate_global->__pyx_codeobj__147 -#define __pyx_codeobj__148 __pyx_mstate_global->__pyx_codeobj__148 -#define __pyx_codeobj__150 __pyx_mstate_global->__pyx_codeobj__150 -#define __pyx_codeobj__152 __pyx_mstate_global->__pyx_codeobj__152 -#define __pyx_codeobj__153 __pyx_mstate_global->__pyx_codeobj__153 -#define __pyx_codeobj__155 __pyx_mstate_global->__pyx_codeobj__155 -#define __pyx_codeobj__156 __pyx_mstate_global->__pyx_codeobj__156 -#define __pyx_codeobj__157 __pyx_mstate_global->__pyx_codeobj__157 -#define __pyx_codeobj__158 __pyx_mstate_global->__pyx_codeobj__158 -#define __pyx_codeobj__159 __pyx_mstate_global->__pyx_codeobj__159 -#define __pyx_codeobj__160 __pyx_mstate_global->__pyx_codeobj__160 -#define __pyx_codeobj__161 __pyx_mstate_global->__pyx_codeobj__161 -#define __pyx_codeobj__162 __pyx_mstate_global->__pyx_codeobj__162 -#define __pyx_codeobj__164 __pyx_mstate_global->__pyx_codeobj__164 -#define __pyx_codeobj__166 __pyx_mstate_global->__pyx_codeobj__166 -#define __pyx_codeobj__168 __pyx_mstate_global->__pyx_codeobj__168 -#define __pyx_codeobj__170 __pyx_mstate_global->__pyx_codeobj__170 -#define __pyx_codeobj__172 __pyx_mstate_global->__pyx_codeobj__172 -#define __pyx_codeobj__174 __pyx_mstate_global->__pyx_codeobj__174 -#define __pyx_codeobj__175 __pyx_mstate_global->__pyx_codeobj__175 -#define __pyx_codeobj__177 __pyx_mstate_global->__pyx_codeobj__177 -#define __pyx_codeobj__179 __pyx_mstate_global->__pyx_codeobj__179 -#define __pyx_codeobj__181 __pyx_mstate_global->__pyx_codeobj__181 -#define __pyx_codeobj__182 __pyx_mstate_global->__pyx_codeobj__182 -#define __pyx_codeobj__183 __pyx_mstate_global->__pyx_codeobj__183 -#define __pyx_codeobj__184 __pyx_mstate_global->__pyx_codeobj__184 -#define __pyx_codeobj__185 __pyx_mstate_global->__pyx_codeobj__185 -#define __pyx_codeobj__187 __pyx_mstate_global->__pyx_codeobj__187 -#define __pyx_codeobj__189 __pyx_mstate_global->__pyx_codeobj__189 -#define __pyx_codeobj__190 __pyx_mstate_global->__pyx_codeobj__190 -#define __pyx_codeobj__191 __pyx_mstate_global->__pyx_codeobj__191 -#define __pyx_codeobj__192 __pyx_mstate_global->__pyx_codeobj__192 -#define __pyx_codeobj__193 __pyx_mstate_global->__pyx_codeobj__193 -#define __pyx_codeobj__194 __pyx_mstate_global->__pyx_codeobj__194 -#define __pyx_codeobj__196 __pyx_mstate_global->__pyx_codeobj__196 -#define __pyx_codeobj__197 __pyx_mstate_global->__pyx_codeobj__197 -#define __pyx_codeobj__198 __pyx_mstate_global->__pyx_codeobj__198 -#define __pyx_codeobj__199 __pyx_mstate_global->__pyx_codeobj__199 -#define __pyx_codeobj__200 __pyx_mstate_global->__pyx_codeobj__200 -#define __pyx_codeobj__201 __pyx_mstate_global->__pyx_codeobj__201 -#define __pyx_codeobj__202 __pyx_mstate_global->__pyx_codeobj__202 -#define __pyx_codeobj__203 __pyx_mstate_global->__pyx_codeobj__203 -#define __pyx_codeobj__204 __pyx_mstate_global->__pyx_codeobj__204 -#define __pyx_codeobj__206 __pyx_mstate_global->__pyx_codeobj__206 -#define __pyx_codeobj__208 __pyx_mstate_global->__pyx_codeobj__208 -#define __pyx_codeobj__209 __pyx_mstate_global->__pyx_codeobj__209 -#define __pyx_codeobj__210 __pyx_mstate_global->__pyx_codeobj__210 -#define __pyx_codeobj__211 __pyx_mstate_global->__pyx_codeobj__211 -#define __pyx_codeobj__212 __pyx_mstate_global->__pyx_codeobj__212 -#define __pyx_codeobj__214 __pyx_mstate_global->__pyx_codeobj__214 -#define __pyx_codeobj__216 __pyx_mstate_global->__pyx_codeobj__216 -#define __pyx_codeobj__218 __pyx_mstate_global->__pyx_codeobj__218 -#define __pyx_codeobj__220 __pyx_mstate_global->__pyx_codeobj__220 -#define __pyx_codeobj__221 __pyx_mstate_global->__pyx_codeobj__221 -#define __pyx_codeobj__222 __pyx_mstate_global->__pyx_codeobj__222 -#define __pyx_codeobj__224 __pyx_mstate_global->__pyx_codeobj__224 -#define __pyx_codeobj__225 __pyx_mstate_global->__pyx_codeobj__225 -#define __pyx_codeobj__226 __pyx_mstate_global->__pyx_codeobj__226 -#define __pyx_codeobj__227 __pyx_mstate_global->__pyx_codeobj__227 -#define __pyx_codeobj__229 __pyx_mstate_global->__pyx_codeobj__229 -#define __pyx_codeobj__230 __pyx_mstate_global->__pyx_codeobj__230 -#define __pyx_codeobj__231 __pyx_mstate_global->__pyx_codeobj__231 -#define __pyx_codeobj__232 __pyx_mstate_global->__pyx_codeobj__232 -#define __pyx_codeobj__233 __pyx_mstate_global->__pyx_codeobj__233 -#define __pyx_codeobj__235 __pyx_mstate_global->__pyx_codeobj__235 -#define __pyx_codeobj__236 __pyx_mstate_global->__pyx_codeobj__236 -#define __pyx_codeobj__237 __pyx_mstate_global->__pyx_codeobj__237 -#define __pyx_codeobj__238 __pyx_mstate_global->__pyx_codeobj__238 -#define __pyx_codeobj__239 __pyx_mstate_global->__pyx_codeobj__239 -#define __pyx_codeobj__242 __pyx_mstate_global->__pyx_codeobj__242 -#define __pyx_codeobj__244 __pyx_mstate_global->__pyx_codeobj__244 -#define __pyx_codeobj__245 __pyx_mstate_global->__pyx_codeobj__245 -#define __pyx_codeobj__246 __pyx_mstate_global->__pyx_codeobj__246 -#define __pyx_codeobj__250 __pyx_mstate_global->__pyx_codeobj__250 -#define __pyx_codeobj__252 __pyx_mstate_global->__pyx_codeobj__252 -#define __pyx_codeobj__253 __pyx_mstate_global->__pyx_codeobj__253 -#define __pyx_codeobj__254 __pyx_mstate_global->__pyx_codeobj__254 -#define __pyx_codeobj__255 __pyx_mstate_global->__pyx_codeobj__255 -#define __pyx_codeobj__257 __pyx_mstate_global->__pyx_codeobj__257 -#define __pyx_codeobj__259 __pyx_mstate_global->__pyx_codeobj__259 -#define __pyx_codeobj__261 __pyx_mstate_global->__pyx_codeobj__261 -#define __pyx_codeobj__263 __pyx_mstate_global->__pyx_codeobj__263 -#define __pyx_codeobj__265 __pyx_mstate_global->__pyx_codeobj__265 -#define __pyx_codeobj__267 __pyx_mstate_global->__pyx_codeobj__267 -#define __pyx_codeobj__270 __pyx_mstate_global->__pyx_codeobj__270 -#define __pyx_codeobj__272 __pyx_mstate_global->__pyx_codeobj__272 -#define __pyx_codeobj__274 __pyx_mstate_global->__pyx_codeobj__274 -#define __pyx_codeobj__276 __pyx_mstate_global->__pyx_codeobj__276 -#define __pyx_codeobj__278 __pyx_mstate_global->__pyx_codeobj__278 -#define __pyx_codeobj__280 __pyx_mstate_global->__pyx_codeobj__280 -#define __pyx_codeobj__282 __pyx_mstate_global->__pyx_codeobj__282 -#define __pyx_codeobj__284 __pyx_mstate_global->__pyx_codeobj__284 -#define __pyx_codeobj__286 __pyx_mstate_global->__pyx_codeobj__286 -#define __pyx_codeobj__288 __pyx_mstate_global->__pyx_codeobj__288 -#define __pyx_codeobj__289 __pyx_mstate_global->__pyx_codeobj__289 -#define __pyx_codeobj__290 __pyx_mstate_global->__pyx_codeobj__290 -#define __pyx_codeobj__291 __pyx_mstate_global->__pyx_codeobj__291 -#define __pyx_codeobj__293 __pyx_mstate_global->__pyx_codeobj__293 -#define __pyx_codeobj__295 __pyx_mstate_global->__pyx_codeobj__295 -#define __pyx_codeobj__297 __pyx_mstate_global->__pyx_codeobj__297 -#define __pyx_codeobj__299 __pyx_mstate_global->__pyx_codeobj__299 -#define __pyx_codeobj__301 __pyx_mstate_global->__pyx_codeobj__301 -#define __pyx_codeobj__303 __pyx_mstate_global->__pyx_codeobj__303 -#define __pyx_codeobj__304 __pyx_mstate_global->__pyx_codeobj__304 -#define __pyx_codeobj__306 __pyx_mstate_global->__pyx_codeobj__306 -#define __pyx_codeobj__308 __pyx_mstate_global->__pyx_codeobj__308 -#define __pyx_codeobj__310 __pyx_mstate_global->__pyx_codeobj__310 -#define __pyx_codeobj__312 __pyx_mstate_global->__pyx_codeobj__312 -#define __pyx_codeobj__314 __pyx_mstate_global->__pyx_codeobj__314 -#define __pyx_codeobj__316 __pyx_mstate_global->__pyx_codeobj__316 -#define __pyx_codeobj__317 __pyx_mstate_global->__pyx_codeobj__317 -#define __pyx_codeobj__319 __pyx_mstate_global->__pyx_codeobj__319 -#define __pyx_codeobj__321 __pyx_mstate_global->__pyx_codeobj__321 -#define __pyx_codeobj__323 __pyx_mstate_global->__pyx_codeobj__323 -#define __pyx_codeobj__324 __pyx_mstate_global->__pyx_codeobj__324 -#define __pyx_codeobj__325 __pyx_mstate_global->__pyx_codeobj__325 -#define __pyx_codeobj__326 __pyx_mstate_global->__pyx_codeobj__326 -#define __pyx_codeobj__328 __pyx_mstate_global->__pyx_codeobj__328 -#define __pyx_codeobj__330 __pyx_mstate_global->__pyx_codeobj__330 -#define __pyx_codeobj__332 __pyx_mstate_global->__pyx_codeobj__332 -#define __pyx_codeobj__333 __pyx_mstate_global->__pyx_codeobj__333 -#define __pyx_codeobj__334 __pyx_mstate_global->__pyx_codeobj__334 -#define __pyx_codeobj__336 __pyx_mstate_global->__pyx_codeobj__336 -#define __pyx_codeobj__337 __pyx_mstate_global->__pyx_codeobj__337 -#define __pyx_codeobj__338 __pyx_mstate_global->__pyx_codeobj__338 -#define __pyx_codeobj__339 __pyx_mstate_global->__pyx_codeobj__339 -#define __pyx_codeobj__340 __pyx_mstate_global->__pyx_codeobj__340 -#define __pyx_codeobj__341 __pyx_mstate_global->__pyx_codeobj__341 -#define __pyx_codeobj__342 __pyx_mstate_global->__pyx_codeobj__342 -#define __pyx_codeobj__344 __pyx_mstate_global->__pyx_codeobj__344 -#define __pyx_codeobj__345 __pyx_mstate_global->__pyx_codeobj__345 -#define __pyx_codeobj__346 __pyx_mstate_global->__pyx_codeobj__346 -#define __pyx_codeobj__347 __pyx_mstate_global->__pyx_codeobj__347 -#define __pyx_codeobj__348 __pyx_mstate_global->__pyx_codeobj__348 -#define __pyx_codeobj__349 __pyx_mstate_global->__pyx_codeobj__349 -#define __pyx_codeobj__350 __pyx_mstate_global->__pyx_codeobj__350 -#define __pyx_codeobj__351 __pyx_mstate_global->__pyx_codeobj__351 -#define __pyx_codeobj__352 __pyx_mstate_global->__pyx_codeobj__352 -#define __pyx_codeobj__353 __pyx_mstate_global->__pyx_codeobj__353 -#define __pyx_codeobj__354 __pyx_mstate_global->__pyx_codeobj__354 -#define __pyx_codeobj__355 __pyx_mstate_global->__pyx_codeobj__355 -#define __pyx_codeobj__356 __pyx_mstate_global->__pyx_codeobj__356 -#define __pyx_codeobj__357 __pyx_mstate_global->__pyx_codeobj__357 -#define __pyx_codeobj__358 __pyx_mstate_global->__pyx_codeobj__358 -#define __pyx_codeobj__359 __pyx_mstate_global->__pyx_codeobj__359 -#define __pyx_codeobj__360 __pyx_mstate_global->__pyx_codeobj__360 -#define __pyx_codeobj__361 __pyx_mstate_global->__pyx_codeobj__361 -#define __pyx_codeobj__362 __pyx_mstate_global->__pyx_codeobj__362 -#define __pyx_codeobj__363 __pyx_mstate_global->__pyx_codeobj__363 -#define __pyx_codeobj__364 __pyx_mstate_global->__pyx_codeobj__364 -#define __pyx_codeobj__365 __pyx_mstate_global->__pyx_codeobj__365 -#define __pyx_codeobj__366 __pyx_mstate_global->__pyx_codeobj__366 -#define __pyx_codeobj__367 __pyx_mstate_global->__pyx_codeobj__367 -#define __pyx_codeobj__368 __pyx_mstate_global->__pyx_codeobj__368 -#define __pyx_codeobj__369 __pyx_mstate_global->__pyx_codeobj__369 -#define __pyx_codeobj__370 __pyx_mstate_global->__pyx_codeobj__370 -#define __pyx_codeobj__371 __pyx_mstate_global->__pyx_codeobj__371 -#define __pyx_codeobj__372 __pyx_mstate_global->__pyx_codeobj__372 -#define __pyx_codeobj__373 __pyx_mstate_global->__pyx_codeobj__373 -#define __pyx_codeobj__374 __pyx_mstate_global->__pyx_codeobj__374 -#define __pyx_codeobj__375 __pyx_mstate_global->__pyx_codeobj__375 -#define __pyx_codeobj__376 __pyx_mstate_global->__pyx_codeobj__376 -#define __pyx_codeobj__377 __pyx_mstate_global->__pyx_codeobj__377 -#define __pyx_codeobj__378 __pyx_mstate_global->__pyx_codeobj__378 -#define __pyx_codeobj__379 __pyx_mstate_global->__pyx_codeobj__379 -#define __pyx_codeobj__380 __pyx_mstate_global->__pyx_codeobj__380 -#define __pyx_codeobj__381 __pyx_mstate_global->__pyx_codeobj__381 -#define __pyx_codeobj__382 __pyx_mstate_global->__pyx_codeobj__382 -#define __pyx_codeobj__383 __pyx_mstate_global->__pyx_codeobj__383 -#define __pyx_codeobj__384 __pyx_mstate_global->__pyx_codeobj__384 -#define __pyx_codeobj__385 __pyx_mstate_global->__pyx_codeobj__385 -#define __pyx_codeobj__386 __pyx_mstate_global->__pyx_codeobj__386 -#define __pyx_codeobj__387 __pyx_mstate_global->__pyx_codeobj__387 -#define __pyx_codeobj__388 __pyx_mstate_global->__pyx_codeobj__388 -#define __pyx_codeobj__389 __pyx_mstate_global->__pyx_codeobj__389 -#define __pyx_codeobj__390 __pyx_mstate_global->__pyx_codeobj__390 -#define __pyx_codeobj__391 __pyx_mstate_global->__pyx_codeobj__391 -#define __pyx_codeobj__392 __pyx_mstate_global->__pyx_codeobj__392 -#define __pyx_codeobj__393 __pyx_mstate_global->__pyx_codeobj__393 -#define __pyx_codeobj__394 __pyx_mstate_global->__pyx_codeobj__394 -#define __pyx_codeobj__395 __pyx_mstate_global->__pyx_codeobj__395 -#define __pyx_codeobj__396 __pyx_mstate_global->__pyx_codeobj__396 -#define __pyx_codeobj__397 __pyx_mstate_global->__pyx_codeobj__397 -#define __pyx_codeobj__398 __pyx_mstate_global->__pyx_codeobj__398 -#define __pyx_codeobj__400 __pyx_mstate_global->__pyx_codeobj__400 -#define __pyx_codeobj__401 __pyx_mstate_global->__pyx_codeobj__401 -#define __pyx_codeobj__402 __pyx_mstate_global->__pyx_codeobj__402 -#define __pyx_codeobj__403 __pyx_mstate_global->__pyx_codeobj__403 -#define __pyx_codeobj__404 __pyx_mstate_global->__pyx_codeobj__404 -#define __pyx_codeobj__405 __pyx_mstate_global->__pyx_codeobj__405 -#define __pyx_codeobj__406 __pyx_mstate_global->__pyx_codeobj__406 -#define __pyx_codeobj__407 __pyx_mstate_global->__pyx_codeobj__407 -#define __pyx_codeobj__408 __pyx_mstate_global->__pyx_codeobj__408 -#define __pyx_codeobj__409 __pyx_mstate_global->__pyx_codeobj__409 -#define __pyx_codeobj__410 __pyx_mstate_global->__pyx_codeobj__410 -#define __pyx_codeobj__411 __pyx_mstate_global->__pyx_codeobj__411 -#define __pyx_codeobj__413 __pyx_mstate_global->__pyx_codeobj__413 -#define __pyx_codeobj__415 __pyx_mstate_global->__pyx_codeobj__415 -#define __pyx_codeobj__416 __pyx_mstate_global->__pyx_codeobj__416 -#define __pyx_codeobj__418 __pyx_mstate_global->__pyx_codeobj__418 -#define __pyx_codeobj__419 __pyx_mstate_global->__pyx_codeobj__419 -#define __pyx_codeobj__420 __pyx_mstate_global->__pyx_codeobj__420 -#define __pyx_codeobj__421 __pyx_mstate_global->__pyx_codeobj__421 -#define __pyx_codeobj__422 __pyx_mstate_global->__pyx_codeobj__422 -#define __pyx_codeobj__423 __pyx_mstate_global->__pyx_codeobj__423 -#define __pyx_codeobj__424 __pyx_mstate_global->__pyx_codeobj__424 -#define __pyx_codeobj__425 __pyx_mstate_global->__pyx_codeobj__425 -#define __pyx_codeobj__427 __pyx_mstate_global->__pyx_codeobj__427 -#define __pyx_codeobj__429 __pyx_mstate_global->__pyx_codeobj__429 -#define __pyx_codeobj__431 __pyx_mstate_global->__pyx_codeobj__431 -#define __pyx_codeobj__433 __pyx_mstate_global->__pyx_codeobj__433 -#define __pyx_codeobj__435 __pyx_mstate_global->__pyx_codeobj__435 -#define __pyx_codeobj__437 __pyx_mstate_global->__pyx_codeobj__437 -#define __pyx_codeobj__438 __pyx_mstate_global->__pyx_codeobj__438 -#define __pyx_codeobj__440 __pyx_mstate_global->__pyx_codeobj__440 -#define __pyx_codeobj__442 __pyx_mstate_global->__pyx_codeobj__442 -#define __pyx_codeobj__444 __pyx_mstate_global->__pyx_codeobj__444 -#define __pyx_codeobj__445 __pyx_mstate_global->__pyx_codeobj__445 -#define __pyx_codeobj__446 __pyx_mstate_global->__pyx_codeobj__446 -#define __pyx_codeobj__447 __pyx_mstate_global->__pyx_codeobj__447 -#define __pyx_codeobj__448 __pyx_mstate_global->__pyx_codeobj__448 -#define __pyx_codeobj__450 __pyx_mstate_global->__pyx_codeobj__450 -#define __pyx_codeobj__452 __pyx_mstate_global->__pyx_codeobj__452 -#define __pyx_codeobj__453 __pyx_mstate_global->__pyx_codeobj__453 -#define __pyx_codeobj__454 __pyx_mstate_global->__pyx_codeobj__454 -#define __pyx_codeobj__455 __pyx_mstate_global->__pyx_codeobj__455 -#define __pyx_codeobj__456 __pyx_mstate_global->__pyx_codeobj__456 -#define __pyx_codeobj__457 __pyx_mstate_global->__pyx_codeobj__457 -#define __pyx_codeobj__459 __pyx_mstate_global->__pyx_codeobj__459 -#define __pyx_codeobj__460 __pyx_mstate_global->__pyx_codeobj__460 -#define __pyx_codeobj__461 __pyx_mstate_global->__pyx_codeobj__461 -#define __pyx_codeobj__462 __pyx_mstate_global->__pyx_codeobj__462 -#define __pyx_codeobj__463 __pyx_mstate_global->__pyx_codeobj__463 -#define __pyx_codeobj__464 __pyx_mstate_global->__pyx_codeobj__464 -#define __pyx_codeobj__465 __pyx_mstate_global->__pyx_codeobj__465 -#define __pyx_codeobj__466 __pyx_mstate_global->__pyx_codeobj__466 -#define __pyx_codeobj__467 __pyx_mstate_global->__pyx_codeobj__467 -#define __pyx_codeobj__469 __pyx_mstate_global->__pyx_codeobj__469 -#define __pyx_codeobj__471 __pyx_mstate_global->__pyx_codeobj__471 -#define __pyx_codeobj__472 __pyx_mstate_global->__pyx_codeobj__472 -#define __pyx_codeobj__473 __pyx_mstate_global->__pyx_codeobj__473 -#define __pyx_codeobj__474 __pyx_mstate_global->__pyx_codeobj__474 -#define __pyx_codeobj__475 __pyx_mstate_global->__pyx_codeobj__475 -#define __pyx_codeobj__477 __pyx_mstate_global->__pyx_codeobj__477 -#define __pyx_codeobj__479 __pyx_mstate_global->__pyx_codeobj__479 -#define __pyx_codeobj__481 __pyx_mstate_global->__pyx_codeobj__481 -#define __pyx_codeobj__483 __pyx_mstate_global->__pyx_codeobj__483 -#define __pyx_codeobj__484 __pyx_mstate_global->__pyx_codeobj__484 -#define __pyx_codeobj__485 __pyx_mstate_global->__pyx_codeobj__485 -#define __pyx_codeobj__487 __pyx_mstate_global->__pyx_codeobj__487 -#define __pyx_codeobj__488 __pyx_mstate_global->__pyx_codeobj__488 -#define __pyx_codeobj__489 __pyx_mstate_global->__pyx_codeobj__489 -#define __pyx_codeobj__490 __pyx_mstate_global->__pyx_codeobj__490 -#define __pyx_codeobj__492 __pyx_mstate_global->__pyx_codeobj__492 -#define __pyx_codeobj__493 __pyx_mstate_global->__pyx_codeobj__493 -#define __pyx_codeobj__494 __pyx_mstate_global->__pyx_codeobj__494 -#define __pyx_codeobj__495 __pyx_mstate_global->__pyx_codeobj__495 -#define __pyx_codeobj__496 __pyx_mstate_global->__pyx_codeobj__496 -#define __pyx_codeobj__498 __pyx_mstate_global->__pyx_codeobj__498 -#define __pyx_codeobj__499 __pyx_mstate_global->__pyx_codeobj__499 -#define __pyx_codeobj__500 __pyx_mstate_global->__pyx_codeobj__500 -#define __pyx_codeobj__501 __pyx_mstate_global->__pyx_codeobj__501 -#define __pyx_codeobj__502 __pyx_mstate_global->__pyx_codeobj__502 /* #### Code section: module_code ### */ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self) { + npy_intp __pyx_r; + + __pyx_r = PyDataType_ELSIZE(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self) { + npy_intp __pyx_r; + + __pyx_r = PyDataType_ALIGNMENT(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1; + __Pyx_RefNannySetupContext("fields", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyDataType_FIELDS(__pyx_v_self); + __Pyx_INCREF(((PyObject *)__pyx_t_1)); + __pyx_r = ((PyObject *)__pyx_t_1); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1; + __Pyx_RefNannySetupContext("names", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyDataType_NAMES(__pyx_v_self); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = ((PyObject*)__pyx_t_1); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self) { + PyArray_ArrayDescr *__pyx_r; + + __pyx_r = PyDataType_SUBARRAY(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self) { + npy_uint64 __pyx_r; + + __pyx_r = PyDataType_FLAGS(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self) { + int __pyx_r; + + __pyx_r = PyArray_MultiIter_NUMITER(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self) { + npy_intp __pyx_r; + + __pyx_r = PyArray_MultiIter_SIZE(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self) { + npy_intp __pyx_r; + + __pyx_r = PyArray_MultiIter_INDEX(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self) { + int __pyx_r; + + __pyx_r = PyArray_MultiIter_NDIM(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self) { + npy_intp *__pyx_r; + + __pyx_r = PyArray_MultiIter_DIMS(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self) { + void **__pyx_r; + + __pyx_r = PyArray_MultiIter_ITERS(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self) { PyObject *__pyx_r; @@ -10028,7 +4847,7 @@ static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArray PyArray_Descr *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyArray_Descr *__pyx_t_1; - __Pyx_RefNannySetupContext("descr", 1); + __Pyx_RefNannySetupContext("descr", 0); __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = PyArray_DESCR(__pyx_v_self); @@ -10117,10 +4936,10 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 1); + __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(2, 774, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -10146,10 +4965,10 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 1); + __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(2, 777, __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, 827, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -10175,10 +4994,10 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 1); + __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(2, 780, __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, 830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -10204,10 +5023,10 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 1); + __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(2, 783, __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, 833, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -10233,10 +5052,10 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 1); + __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(2, 786, __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, 836, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -10259,22 +5078,24 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("PyDataType_SHAPE", 1); + PyObject *__pyx_t_2; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); __pyx_t_1 = PyDataType_HASSUBARRAY(__pyx_v_d); if (__pyx_t_1) { __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); - __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + __pyx_t_2 = __pyx_f_5numpy_5dtype_8subarray_subarray(__pyx_v_d)->shape; + __Pyx_INCREF(((PyObject*)__pyx_t_2)); + __pyx_r = ((PyObject*)__pyx_t_2); goto __pyx_L0; } /*else*/ { __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_empty_tuple); - __pyx_r = __pyx_empty_tuple; + __Pyx_INCREF(__pyx_mstate_global->__pyx_empty_tuple); + __pyx_r = __pyx_mstate_global->__pyx_empty_tuple; goto __pyx_L0; } @@ -10295,7 +5116,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(2, 970, __pyx_L1_error) + __pyx_t_1 = PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(3, 1028, __pyx_L1_error) /* function exit code */ @@ -10311,7 +5132,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("get_array_base", 1); + __Pyx_RefNannySetupContext("get_array_base", 0); __pyx_v_base = PyArray_BASE(__pyx_v_arr); @@ -10349,10 +5170,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_array", 1); + __Pyx_RefNannySetupContext("import_array", 0); { __Pyx_PyThreadState_declare @@ -10363,7 +5186,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(2, 982, __pyx_L3_error) + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1040, __pyx_L3_error) } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -10372,19 +5195,26 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + __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(2, 983, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1041, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 984, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __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((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; + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1042, __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(2, 984, __pyx_L5_except_error) + __PYX_ERR(3, 1042, __pyx_L5_except_error) } goto __pyx_L5_except_error; @@ -10406,6 +5236,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -10425,10 +5256,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_umath", 1); + __Pyx_RefNannySetupContext("import_umath", 0); { __Pyx_PyThreadState_declare @@ -10439,7 +5272,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(2, 988, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1046, __pyx_L3_error) } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -10448,19 +5281,26 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + __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(2, 989, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1047, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 990, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __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((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; + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1048, __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(2, 990, __pyx_L5_except_error) + __PYX_ERR(3, 1048, __pyx_L5_except_error) } goto __pyx_L5_except_error; @@ -10482,6 +5322,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -10501,10 +5342,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_ufunc", 1); + __Pyx_RefNannySetupContext("import_ufunc", 0); { __Pyx_PyThreadState_declare @@ -10515,7 +5358,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(2, 994, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1052, __pyx_L3_error) } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -10524,19 +5367,26 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + __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(2, 995, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1053, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 996, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __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((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; + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1054, __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(2, 996, __pyx_L5_except_error) + __PYX_ERR(3, 1054, __pyx_L5_except_error) } goto __pyx_L5_except_error; @@ -10558,6 +5408,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -10644,10 +5495,15 @@ static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *__pyx_v_fun __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5[5]; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_check_success", 1); + __Pyx_RefNannySetupContext("_ta_check_success", 0); switch (__pyx_v_ret_code) { case 0: @@ -10660,148 +5516,157 @@ static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *__pyx_v_fun break; case 1: - __Pyx_INCREF(__pyx_kp_s_Library_Not_Initialized_TA_LIB_N); - __pyx_v_description = __pyx_kp_s_Library_Not_Initialized_TA_LIB_N; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Library_Not_Initialized_TA_LIB_N); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Library_Not_Initialized_TA_LIB_N; break; case 2: - __Pyx_INCREF(__pyx_kp_s_Bad_Parameter_TA_BAD_PARAM); - __pyx_v_description = __pyx_kp_s_Bad_Parameter_TA_BAD_PARAM; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Bad_Parameter_TA_BAD_PARAM); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Bad_Parameter_TA_BAD_PARAM; break; case 3: - __Pyx_INCREF(__pyx_kp_s_Allocation_Error_TA_ALLOC_ERR); - __pyx_v_description = __pyx_kp_s_Allocation_Error_TA_ALLOC_ERR; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Allocation_Error_TA_ALLOC_ERR); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Allocation_Error_TA_ALLOC_ERR; break; case 4: - __Pyx_INCREF(__pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU); - __pyx_v_description = __pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Group_Not_Found_TA_GROUP_NOT_FOU); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Group_Not_Found_TA_GROUP_NOT_FOU; break; case 5: - __Pyx_INCREF(__pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F); - __pyx_v_description = __pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Function_Not_Found_TA_FUNC_NOT_F); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Function_Not_Found_TA_FUNC_NOT_F; break; case 6: - __Pyx_INCREF(__pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE); - __pyx_v_description = __pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_Handle_TA_INVALID_HANDLE); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_Handle_TA_INVALID_HANDLE; break; case 7: - __Pyx_INCREF(__pyx_kp_s_Invalid_Parameter_Holder_TA_INVA); - __pyx_v_description = __pyx_kp_s_Invalid_Parameter_Holder_TA_INVA; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Holder_TA_INVA); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Holder_TA_INVA; break; case 8: - __Pyx_INCREF(__pyx_kp_s_Invalid_Parameter_Holder_Type_TA); - __pyx_v_description = __pyx_kp_s_Invalid_Parameter_Holder_Type_TA; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Holder_Type_TA); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Holder_Type_TA; break; case 9: - __Pyx_INCREF(__pyx_kp_s_Invalid_Parameter_Function_TA_IN); - __pyx_v_description = __pyx_kp_s_Invalid_Parameter_Function_TA_IN; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Function_TA_IN); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Function_TA_IN; break; case 10: - __Pyx_INCREF(__pyx_kp_s_Input_Not_All_Initialized_TA_INP); - __pyx_v_description = __pyx_kp_s_Input_Not_All_Initialized_TA_INP; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Input_Not_All_Initialized_TA_INP); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Input_Not_All_Initialized_TA_INP; break; case 11: - __Pyx_INCREF(__pyx_kp_s_Output_Not_All_Initialized_TA_OU); - __pyx_v_description = __pyx_kp_s_Output_Not_All_Initialized_TA_OU; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Output_Not_All_Initialized_TA_OU); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Output_Not_All_Initialized_TA_OU; break; case 12: - __Pyx_INCREF(__pyx_kp_s_Out_of_Range_Start_Index_TA_OUT); - __pyx_v_description = __pyx_kp_s_Out_of_Range_Start_Index_TA_OUT; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Out_of_Range_Start_Index_TA_OUT); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Out_of_Range_Start_Index_TA_OUT; break; case 13: - __Pyx_INCREF(__pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF); - __pyx_v_description = __pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Out_of_Range_End_Index_TA_OUT_OF); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Out_of_Range_End_Index_TA_OUT_OF; break; case 14: - __Pyx_INCREF(__pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS); - __pyx_v_description = __pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_List_Type_TA_INVALID_LIS); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_List_Type_TA_INVALID_LIS; break; case 15: - __Pyx_INCREF(__pyx_kp_s_Bad_Object_TA_BAD_OBJECT); - __pyx_v_description = __pyx_kp_s_Bad_Object_TA_BAD_OBJECT; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Bad_Object_TA_BAD_OBJECT); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Bad_Object_TA_BAD_OBJECT; break; case 16: - __Pyx_INCREF(__pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED); - __pyx_v_description = __pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Not_Supported_TA_NOT_SUPPORTED); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Not_Supported_TA_NOT_SUPPORTED; break; case 0x1388: - __Pyx_INCREF(__pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR); - __pyx_v_description = __pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Internal_Error_TA_INTERNAL_ERROR); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Internal_Error_TA_INTERNAL_ERROR; break; case 0xFFFF: - __Pyx_INCREF(__pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR); - __pyx_v_description = __pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Unknown_Error_TA_UNKNOWN_ERR); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Unknown_Error_TA_UNKNOWN_ERR; break; default: - __Pyx_INCREF(__pyx_kp_s_Unknown_Error); - __pyx_v_description = __pyx_kp_s_Unknown_Error; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Unknown_Error); + __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Unknown_Error; break; } - __pyx_t_1 = __Pyx_PyInt_From_TA_RetCode(__pyx_v_ret_code); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_v_function_name); - __Pyx_GIVEREF(__pyx_v_function_name); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_function_name)) __PYX_ERR(0, 48, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_description); - __Pyx_GIVEREF(__pyx_v_description); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_description)) __PYX_ERR(0, 48, __pyx_L1_error); - __pyx_t_1 = 0; + __pyx_t_2 = NULL; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_function_failed_with_error_co, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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[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_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = 1; + { + 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_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 47, __pyx_L1_error) + __PYX_ERR(1, 47, __pyx_L1_error) /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -10819,7 +5684,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_1_ta_check_success = {"_ta_check_success", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_1_ta_check_success, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib__ta_check_success, "_ta_check_success(str function_name, TA_RetCode ret_code)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_1_ta_check_success = {"_ta_check_success", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_1_ta_check_success, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib__ta_check_success}; static PyObject *__pyx_pw_5talib_7_ta_lib_1_ta_check_success(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -10841,7 +5707,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_check_success (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -10849,80 +5715,67 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function_name,&__pyx_n_s_ret_code,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 6, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 6, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_function_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ret_code)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("_ta_check_success", 1, 2, 2, 1); __PYX_ERR(0, 6, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_check_success") < 0)) __PYX_ERR(0, 6, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 6, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 6, __pyx_L3_error) } __pyx_v_function_name = ((PyObject*)values[0]); - __pyx_v_ret_code = __Pyx_PyInt_As_TA_RetCode(values[1]); if (unlikely((__pyx_v_ret_code == ((TA_RetCode)-1)) && PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error) + __pyx_v_ret_code = __Pyx_PyLong_As_TA_RetCode(values[1]); if (unlikely((__pyx_v_ret_code == ((TA_RetCode)-1)) && PyErr_Occurred())) __PYX_ERR(1, 6, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_check_success", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 6, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_check_success", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 6, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_function_name), (&PyString_Type), 1, "function_name", 1))) __PYX_ERR(0, 6, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_function_name), (&PyUnicode_Type), 1, "function_name", 1))) __PYX_ERR(1, 6, __pyx_L1_error) __pyx_r = __pyx_pf_5talib_7_ta_lib__ta_check_success(__pyx_self, __pyx_v_function_name, __pyx_v_ret_code); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10934,9 +5787,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib__ta_check_success(CYTHON_UNUSED PyObje int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_check_success", 1); + __Pyx_RefNannySetupContext("_ta_check_success", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_v_function_name, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_v_function_name, __pyx_v_ret_code, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -10956,7 +5809,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib__ta_check_success(CYTHON_UNUSED PyObje /* Python wrapper */ static PyObject *__pyx_pw_5talib_7_ta_lib_3_ta_initialize(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_3_ta_initialize = {"_ta_initialize", (PyCFunction)__pyx_pw_5talib_7_ta_lib_3_ta_initialize, METH_NOARGS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_2_ta_initialize, "_ta_initialize()"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_3_ta_initialize = {"_ta_initialize", (PyCFunction)__pyx_pw_5talib_7_ta_lib_3_ta_initialize, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_2_ta_initialize}; static PyObject *__pyx_pw_5talib_7_ta_lib_3_ta_initialize(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; @@ -10978,11 +5832,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_2_ta_initialize(CYTHON_UNUSED PyObject int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_initialize", 1); + __Pyx_RefNannySetupContext("_ta_initialize", 0); __pyx_v_ret_code = TA_Initialize(); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_Initialize, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_Initialize, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 53, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -11003,7 +5857,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_2_ta_initialize(CYTHON_UNUSED PyObject /* Python wrapper */ static PyObject *__pyx_pw_5talib_7_ta_lib_5_ta_shutdown(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_5_ta_shutdown = {"_ta_shutdown", (PyCFunction)__pyx_pw_5talib_7_ta_lib_5_ta_shutdown, METH_NOARGS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_4_ta_shutdown, "_ta_shutdown()"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_5_ta_shutdown = {"_ta_shutdown", (PyCFunction)__pyx_pw_5talib_7_ta_lib_5_ta_shutdown, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_4_ta_shutdown}; static PyObject *__pyx_pw_5talib_7_ta_lib_5_ta_shutdown(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; @@ -11025,11 +5880,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_4_ta_shutdown(CYTHON_UNUSED PyObject * int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_shutdown", 1); + __Pyx_RefNannySetupContext("_ta_shutdown", 0); __pyx_v_ret_code = TA_Shutdown(); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_Shutdown, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_Shutdown, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 58, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -11056,7 +5911,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7MA_Type_1__init__ = {"__init__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_7MA_Type_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_7MA_Type___init__, "MA_Type.__init__(self)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7MA_Type_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_7MA_Type_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_7MA_Type___init__}; static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_1__init__(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -11077,7 +5933,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -11085,47 +5941,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 63, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 63, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 63, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 63, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 63, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MA_Type.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -11134,11 +5982,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_7MA_Type___init__(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -11153,83 +5998,83 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 1); + __Pyx_RefNannySetupContext("__init__", 0); - __pyx_t_1 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error) + __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_kp_s_Simple_Moving_Average) < 0) __PYX_ERR(0, 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_n_s_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_EMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) + __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_kp_s_Exponential_Moving_Average) < 0) __PYX_ERR(0, 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_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 67, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_WMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 67, __pyx_L1_error) + __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_kp_s_Weighted_Moving_Average) < 0) __PYX_ERR(0, 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_n_s_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 68, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_DEMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error) + __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_kp_s_Double_Exponential_Moving_Averag) < 0) __PYX_ERR(0, 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_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_TEMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error) + __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_kp_s_Triple_Exponential_Moving_Averag) < 0) __PYX_ERR(0, 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_n_s_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_TRIMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error) + __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_kp_s_Triangular_Moving_Average) < 0) __PYX_ERR(0, 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_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_KAMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error) + __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_kp_s_Kaufman_Adaptive_Moving_Average) < 0) __PYX_ERR(0, 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_n_s_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_MAMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) + __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_kp_s_MESA_Adaptive_Moving_Average) < 0) __PYX_ERR(0, 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_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_T3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error) + __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_kp_s_Triple_Generalized_Double_Expone) < 0) __PYX_ERR(0, 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_n_s_lookup, __pyx_t_1) < 0) __PYX_ERR(0, 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; @@ -11257,7 +6102,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7MA_Type_3__getitem__ = {"__getitem__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_7MA_Type_3__getitem__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_7MA_Type_2__getitem__, "MA_Type.__getitem__(self, type_)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7MA_Type_3__getitem__ = {"__getitem__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_7MA_Type_3__getitem__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_7MA_Type_2__getitem__}; static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_3__getitem__(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -11279,7 +6125,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -11287,61 +6133,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_type,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 76, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 76, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_type)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, 1); __PYX_ERR(0, 76, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__getitem__") < 0)) __PYX_ERR(0, 76, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 76, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 76, __pyx_L3_error) } __pyx_v_self = values[0]; __pyx_v_type_ = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 76, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 76, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MA_Type.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -11350,11 +6181,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(__pyx_self, __pyx_v_self, __pyx_v_type_); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -11368,12 +6196,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(CYTHON_UNUSED Py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 1); + __Pyx_RefNannySetupContext("__getitem__", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_lookup); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lookup); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_type_); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_type_); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; @@ -11402,7 +6230,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7_ta_set_unstable_period = {"_ta_set_unstable_period", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_7_ta_set_unstable_period, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_6_ta_set_unstable_period, "_ta_set_unstable_period(name, period)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7_ta_set_unstable_period = {"_ta_set_unstable_period", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_7_ta_set_unstable_period, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_6_ta_set_unstable_period}; static PyObject *__pyx_pw_5talib_7_ta_lib_7_ta_set_unstable_period(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -11424,7 +6253,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_set_unstable_period (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -11432,61 +6261,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_period,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 90, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 90, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_period)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("_ta_set_unstable_period", 1, 2, 2, 1); __PYX_ERR(0, 90, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_set_unstable_period") < 0)) __PYX_ERR(0, 90, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 90, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 90, __pyx_L3_error) } __pyx_v_name = values[0]; __pyx_v_period = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_set_unstable_period", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 90, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_set_unstable_period", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 90, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_set_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -11495,11 +6309,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(__pyx_self, __pyx_v_name, __pyx_v_period); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -11517,21 +6328,21 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(CYTHON_UNUSED int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_set_unstable_period", 1); + __Pyx_RefNannySetupContext("_ta_set_unstable_period", 0); - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ta_func_unst_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 92, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 92, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyInt_As_TA_FuncUnstId(__pyx_t_2); if (unlikely((__pyx_t_3 == ((TA_FuncUnstId)-1)) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_As_TA_FuncUnstId(__pyx_t_2); if (unlikely((__pyx_t_3 == ((TA_FuncUnstId)-1)) && PyErr_Occurred())) __PYX_ERR(1, 92, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_id = __pyx_t_3; - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_period); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyLong_As_unsigned_int(__pyx_v_period); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(1, 93, __pyx_L1_error) __pyx_v_ret_code = TA_SetUnstablePeriod(__pyx_v_id, __pyx_t_4); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SetUnstablePeriod, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetUnstablePeriod, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 94, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -11559,7 +6370,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_9_ta_get_unstable_period = {"_ta_get_unstable_period", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_9_ta_get_unstable_period, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8_ta_get_unstable_period, "_ta_get_unstable_period(name)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_9_ta_get_unstable_period = {"_ta_get_unstable_period", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_9_ta_get_unstable_period, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8_ta_get_unstable_period}; static PyObject *__pyx_pw_5talib_7_ta_lib_9_ta_get_unstable_period(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -11580,7 +6392,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_get_unstable_period (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -11588,47 +6400,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 96, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_get_unstable_period") < 0)) __PYX_ERR(0, 96, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 96, __pyx_L3_error) } __pyx_v_name = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_get_unstable_period", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 96, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_get_unstable_period", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 96, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_get_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -11637,11 +6441,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(__pyx_self, __pyx_v_name); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -11658,21 +6459,21 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(CYTHON_UNUSED int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_get_unstable_period", 1); + __Pyx_RefNannySetupContext("_ta_get_unstable_period", 0); - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ta_func_unst_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyInt_As_TA_FuncUnstId(__pyx_t_2); if (unlikely((__pyx_t_3 == ((TA_FuncUnstId)-1)) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_As_TA_FuncUnstId(__pyx_t_2); if (unlikely((__pyx_t_3 == ((TA_FuncUnstId)-1)) && PyErr_Occurred())) __PYX_ERR(1, 98, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_id = __pyx_t_3; __pyx_v_period = TA_GetUnstablePeriod(__pyx_v_id); __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_period); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_unsigned_int(__pyx_v_period); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; @@ -11700,7 +6501,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_11_ta_set_compatibility = {"_ta_set_compatibility", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_11_ta_set_compatibility, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_10_ta_set_compatibility, "_ta_set_compatibility(value)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_11_ta_set_compatibility = {"_ta_set_compatibility", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_11_ta_set_compatibility, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_10_ta_set_compatibility}; static PyObject *__pyx_pw_5talib_7_ta_lib_11_ta_set_compatibility(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -11721,7 +6523,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_set_compatibility (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -11729,47 +6531,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 102, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_set_compatibility") < 0)) __PYX_ERR(0, 102, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 102, __pyx_L3_error) } __pyx_v_value = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_set_compatibility", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 102, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_set_compatibility", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 102, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_set_compatibility", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -11778,11 +6572,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(__pyx_self, __pyx_v_value); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -11797,12 +6588,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(CYTHON_UNUSED int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_set_compatibility", 1); + __Pyx_RefNannySetupContext("_ta_set_compatibility", 0); - __pyx_t_1 = __Pyx_PyInt_As_TA_Compatibility(__pyx_v_value); if (unlikely((__pyx_t_1 == ((TA_Compatibility)-1)) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_As_TA_Compatibility(__pyx_v_value); if (unlikely((__pyx_t_1 == ((TA_Compatibility)-1)) && PyErr_Occurred())) __PYX_ERR(1, 104, __pyx_L1_error) __pyx_v_ret_code = TA_SetCompatibility(__pyx_t_1); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SetCompatibility, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetCompatibility, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -11823,7 +6614,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(CYTHON_UNUSED /* Python wrapper */ static PyObject *__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_13_ta_get_compatibility = {"_ta_get_compatibility", (PyCFunction)__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility, METH_NOARGS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_12_ta_get_compatibility, "_ta_get_compatibility()"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_13_ta_get_compatibility = {"_ta_get_compatibility", (PyCFunction)__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_12_ta_get_compatibility}; static PyObject *__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; @@ -11845,12 +6637,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(CYTHON_UNUSED int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_get_compatibility", 1); + __Pyx_RefNannySetupContext("_ta_get_compatibility", 0); __pyx_v_value = TA_GetCompatibility(); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -11877,7 +6669,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_15_ta_set_candle_settings = {"_ta_set_candle_settings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_15_ta_set_candle_settings, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_14_ta_set_candle_settings, "_ta_set_candle_settings(settingtype, rangetype, avgperiod, factor)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_15_ta_set_candle_settings = {"_ta_set_candle_settings", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_15_ta_set_candle_settings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_14_ta_set_candle_settings}; static PyObject *__pyx_pw_5talib_7_ta_lib_15_ta_set_candle_settings(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -11901,7 +6694,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_set_candle_settings (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -11909,72 +6702,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_settingtype,&__pyx_n_s_rangetype,&__pyx_n_s_avgperiod,&__pyx_n_s_factor,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(1, 124, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 124, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 124, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 124, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_settingtype)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rangetype)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, 1); __PYX_ERR(0, 124, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_avgperiod)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, 2); __PYX_ERR(0, 124, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_factor)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, 3); __PYX_ERR(0, 124, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_set_candle_settings") < 0)) __PYX_ERR(0, 124, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 124, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 124, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 124, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(1, 124, __pyx_L3_error) } __pyx_v_settingtype = values[0]; __pyx_v_rangetype = values[1]; @@ -11983,15 +6750,12 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 124, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, __pyx_nargs); __PYX_ERR(1, 124, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_set_candle_settings", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -12000,11 +6764,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_14_ta_set_candle_settings(__pyx_self, __pyx_v_settingtype, __pyx_v_rangetype, __pyx_v_avgperiod, __pyx_v_factor); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -12022,15 +6783,15 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_14_ta_set_candle_settings(CYTHON_UNUSE int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_set_candle_settings", 1); + __Pyx_RefNannySetupContext("_ta_set_candle_settings", 0); - __pyx_t_1 = __Pyx_PyInt_As_TA_CandleSettingType(__pyx_v_settingtype); if (unlikely((__pyx_t_1 == ((TA_CandleSettingType)-1)) && PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyInt_As_TA_RangeType(__pyx_v_rangetype); if (unlikely((__pyx_t_2 == ((TA_RangeType)-1)) && PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_avgperiod); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L1_error) - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_factor); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_As_TA_CandleSettingType(__pyx_v_settingtype); if (unlikely((__pyx_t_1 == ((TA_CandleSettingType)-1)) && PyErr_Occurred())) __PYX_ERR(1, 126, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_As_TA_RangeType(__pyx_v_rangetype); if (unlikely((__pyx_t_2 == ((TA_RangeType)-1)) && PyErr_Occurred())) __PYX_ERR(1, 126, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_v_avgperiod); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 126, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFloat_AsDouble(__pyx_v_factor); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(1, 126, __pyx_L1_error) __pyx_v_ret_code = TA_SetCandleSettings(__pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_t_4); - __pyx_t_5 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SetCandleSettings, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 127, __pyx_L1_error) + __pyx_t_5 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetCandleSettings, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -12057,7 +6818,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_17_ta_restore_candle_default_settings = {"_ta_restore_candle_default_settings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_17_ta_restore_candle_default_settings, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_16_ta_restore_candle_default_settings, "_ta_restore_candle_default_settings(settingtype)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_17_ta_restore_candle_default_settings = {"_ta_restore_candle_default_settings", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_17_ta_restore_candle_default_settings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_16_ta_restore_candle_default_settings}; static PyObject *__pyx_pw_5talib_7_ta_lib_17_ta_restore_candle_default_settings(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -12078,7 +6840,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_restore_candle_default_settings (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -12086,47 +6848,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_settingtype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 129, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_settingtype)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 129, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_restore_candle_default_settings") < 0)) __PYX_ERR(0, 129, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 129, __pyx_L3_error) } __pyx_v_settingtype = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_restore_candle_default_settings", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 129, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_restore_candle_default_settings", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 129, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_restore_candle_default_settings", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -12135,11 +6889,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings(__pyx_self, __pyx_v_settingtype); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -12154,12 +6905,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings( int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_restore_candle_default_settings", 1); + __Pyx_RefNannySetupContext("_ta_restore_candle_default_settings", 0); - __pyx_t_1 = __Pyx_PyInt_As_TA_CandleSettingType(__pyx_v_settingtype); if (unlikely((__pyx_t_1 == ((TA_CandleSettingType)-1)) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_As_TA_CandleSettingType(__pyx_v_settingtype); if (unlikely((__pyx_t_1 == ((TA_CandleSettingType)-1)) && PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L1_error) __pyx_v_ret_code = TA_RestoreCandleDefaultSettings(__pyx_t_1); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_RestoreCandleDefaultSettings, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_RestoreCandleDefaultSettings, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 132, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -12183,7 +6934,8 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -12193,30 +6945,43 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v __pyx_t_1 = (PyArray_TYPE(__pyx_v_real) != NPY_DOUBLE); if (unlikely(__pyx_t_1)) { - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __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((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, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(3, 22, __pyx_L1_error) + __PYX_ERR(4, 22, __pyx_L1_error) } - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4ndim_ndim(__pyx_v_real); if (unlikely(__pyx_t_3 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(3, 23, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 1); + __pyx_t_1 = (__pyx_f_5numpy_7ndarray_4ndim_ndim(__pyx_v_real) != 1); if (unlikely(__pyx_t_1)) { - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 1; + { + 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); + } __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(3, 24, __pyx_L1_error) + __PYX_ERR(4, 24, __pyx_L1_error) } - __pyx_t_1 = (!((PyArray_FLAGS(__pyx_v_real) & NPY_C_CONTIGUOUS) != 0)); + __pyx_t_1 = (!((PyArray_FLAGS(__pyx_v_real) & NPY_ARRAY_C_CONTIGUOUS) != 0)); if (__pyx_t_1) { - __pyx_t_2 = ((PyObject *)PyArray_GETCONTIGUOUS(__pyx_v_real)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 26, __pyx_L1_error) + __pyx_t_2 = ((PyObject *)PyArray_GETCONTIGUOUS(__pyx_v_real)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_2)); __pyx_t_2 = 0; @@ -12232,6 +6997,7 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("talib._ta_lib.check_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -12246,26 +7012,32 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length2(PyArrayObject *__pyx_v_a1, npy_intp __pyx_v_length; npy_intp __pyx_r; __Pyx_RefNannyDeclarations - npy_intp *__pyx_t_1; - int __pyx_t_2; + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("check_length2", 1); + __Pyx_RefNannySetupContext("check_length2", 0); - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 32, __pyx_L1_error) - __pyx_v_length = (__pyx_t_1[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1)[0]); - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 33, __pyx_L1_error) - __pyx_t_2 = (__pyx_v_length != (__pyx_t_1[0])); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2)[0])); + if (unlikely(__pyx_t_1)) { - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 34, __pyx_L1_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(3, 34, __pyx_L1_error) + __pyx_t_3 = NULL; + __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((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, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 34, __pyx_L1_error) } @@ -12275,9 +7047,10 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length2(PyArrayObject *__pyx_v_a1, /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __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; @@ -12288,38 +7061,50 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *__pyx_v_a1, npy_intp __pyx_v_length; npy_intp __pyx_r; __Pyx_RefNannyDeclarations - npy_intp *__pyx_t_1; - int __pyx_t_2; + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("check_length3", 1); + __Pyx_RefNannySetupContext("check_length3", 0); - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 40, __pyx_L1_error) - __pyx_v_length = (__pyx_t_1[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1)[0]); - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 41, __pyx_L1_error) - __pyx_t_2 = (__pyx_v_length != (__pyx_t_1[0])); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2)[0])); + if (unlikely(__pyx_t_1)) { - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 42, __pyx_L1_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(3, 42, __pyx_L1_error) + __pyx_t_3 = NULL; + __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((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, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 42, __pyx_L1_error) } - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 43, __pyx_L1_error) - __pyx_t_2 = (__pyx_v_length != (__pyx_t_1[0])); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3)[0])); + if (unlikely(__pyx_t_1)) { - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 44, __pyx_L1_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(3, 44, __pyx_L1_error) + __pyx_t_3 = NULL; + __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((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); + } + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 44, __pyx_L1_error) } @@ -12329,9 +7114,10 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *__pyx_v_a1, /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __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; @@ -12342,50 +7128,68 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, npy_intp __pyx_v_length; npy_intp __pyx_r; __Pyx_RefNannyDeclarations - npy_intp *__pyx_t_1; - int __pyx_t_2; + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("check_length4", 1); + __Pyx_RefNannySetupContext("check_length4", 0); - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 50, __pyx_L1_error) - __pyx_v_length = (__pyx_t_1[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1)[0]); - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 51, __pyx_L1_error) - __pyx_t_2 = (__pyx_v_length != (__pyx_t_1[0])); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2)[0])); + if (unlikely(__pyx_t_1)) { - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 52, __pyx_L1_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(3, 52, __pyx_L1_error) + __pyx_t_3 = NULL; + __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((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, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 52, __pyx_L1_error) } - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 53, __pyx_L1_error) - __pyx_t_2 = (__pyx_v_length != (__pyx_t_1[0])); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3)[0])); + if (unlikely(__pyx_t_1)) { - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 54, __pyx_L1_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(3, 54, __pyx_L1_error) + __pyx_t_3 = NULL; + __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((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); + } + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 54, __pyx_L1_error) } - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a4); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 55, __pyx_L1_error) - __pyx_t_2 = (__pyx_v_length != (__pyx_t_1[0])); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a4)[0])); + if (unlikely(__pyx_t_1)) { - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 56, __pyx_L1_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(3, 56, __pyx_L1_error) + __pyx_t_3 = NULL; + __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((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, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 56, __pyx_L1_error) } @@ -12395,9 +7199,10 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __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; @@ -12609,34 +7414,32 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_double_array(npy_intp __pyx_v PyArrayObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; - int __pyx_t_4; - npy_intp __pyx_t_5; - int __pyx_t_6; + npy_intp __pyx_t_2; + int __pyx_t_3; + npy_intp __pyx_t_4; + int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("make_double_array", 1); + __Pyx_RefNannySetupContext("make_double_array", 0); - __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_length), NPY_DOUBLE, NPY_DEFAULT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 125, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_length), NPY_DOUBLE, NPY_ARRAY_DEFAULT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 126, __pyx_L1_error) - __pyx_v_outreal_data = ((double *)__pyx_t_2); + __pyx_v_outreal_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)); - __pyx_t_3 = __pyx_v_length; - __pyx_t_4 = __pyx_v_lookback; - __pyx_t_6 = (__pyx_t_3 < __pyx_t_4); - if (__pyx_t_6) { - __pyx_t_5 = __pyx_t_3; + __pyx_t_2 = __pyx_v_length; + __pyx_t_3 = __pyx_v_lookback; + __pyx_t_5 = (__pyx_t_2 < __pyx_t_3); + if (__pyx_t_5) { + __pyx_t_4 = __pyx_t_2; } else { - __pyx_t_5 = __pyx_t_4; + __pyx_t_4 = __pyx_t_3; } - __pyx_t_3 = __pyx_t_5; - for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { + __pyx_t_2 = __pyx_t_4; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_2; __pyx_v_i++) { (__pyx_v_outreal_data[__pyx_v_i]) = __pyx_v_5talib_7_ta_lib_NaN; } @@ -12667,34 +7470,32 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_int_array(npy_intp __pyx_v_le PyArrayObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; - int __pyx_t_4; - npy_intp __pyx_t_5; - int __pyx_t_6; + npy_intp __pyx_t_2; + int __pyx_t_3; + npy_intp __pyx_t_4; + int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("make_int_array", 1); + __Pyx_RefNannySetupContext("make_int_array", 0); - __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_length), NPY_INT32, NPY_DEFAULT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 135, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_length), NPY_INT32, NPY_ARRAY_DEFAULT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 136, __pyx_L1_error) - __pyx_v_outinteger_data = ((int *)__pyx_t_2); + __pyx_v_outinteger_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)); - __pyx_t_3 = __pyx_v_length; - __pyx_t_4 = __pyx_v_lookback; - __pyx_t_6 = (__pyx_t_3 < __pyx_t_4); - if (__pyx_t_6) { - __pyx_t_5 = __pyx_t_3; + __pyx_t_2 = __pyx_v_length; + __pyx_t_3 = __pyx_v_lookback; + __pyx_t_5 = (__pyx_t_2 < __pyx_t_3); + if (__pyx_t_5) { + __pyx_t_4 = __pyx_t_2; } else { - __pyx_t_5 = __pyx_t_4; + __pyx_t_4 = __pyx_t_3; } - __pyx_t_3 = __pyx_t_5; - for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { + __pyx_t_2 = __pyx_t_4; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_2; __pyx_v_i++) { (__pyx_v_outinteger_data[__pyx_v_i]) = 0; } @@ -12719,16 +7520,252 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_int_array(npy_intp __pyx_v_le /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_19ACOS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_19ACCBANDS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_18ACOS, " ACOS(real)\n\n Vector Trigonometric ACos (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_19ACOS = {"ACOS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_19ACOS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_18ACOS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_19ACOS(PyObject *__pyx_self, +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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + int __pyx_v_timeperiod; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ACCBANDS (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 142, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 142, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 142, __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(4, 142, __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, "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) } + } + } else { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 142, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 142, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 142, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 142, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_high = ((PyArrayObject *)values[0]); + __pyx_v_low = ((PyArrayObject *)values[1]); + __pyx_v_close = ((PyArrayObject *)values[2]); + if (values[3]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 144, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ACCBANDS", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 142, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.ACCBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 144, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 144, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 144, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_18ACCBANDS(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_18ACCBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { + npy_intp __pyx_v_length; + int __pyx_v_begidx; + int __pyx_v_endidx; + int __pyx_v_lookback; + TA_RetCode __pyx_v_retCode; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + PyArrayObject *__pyx_v_outrealupperband = 0; + PyArrayObject *__pyx_v_outrealmiddleband = 0; + PyArrayObject *__pyx_v_outreallowerband = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_intp __pyx_t_2; + npy_int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ACCBANDS", 0); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __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)-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) + __pyx_v_begidx = __pyx_t_3; + + __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); + + __pyx_v_lookback = (__pyx_v_begidx + TA_ACCBANDS_Lookback(__pyx_v_timeperiod)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_outrealupperband = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_outrealmiddleband = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_outreallowerband = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + __pyx_v_retCode = TA_ACCBANDS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealupperband)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealmiddleband)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreallowerband)) + __pyx_v_lookback)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ACCBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_outrealupperband); + __Pyx_GIVEREF((PyObject *)__pyx_v_outrealupperband); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outrealupperband)) != (0)) __PYX_ERR(4, 179, __pyx_L1_error); + __Pyx_INCREF((PyObject *)__pyx_v_outrealmiddleband); + __Pyx_GIVEREF((PyObject *)__pyx_v_outrealmiddleband); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outrealmiddleband)) != (0)) __PYX_ERR(4, 179, __pyx_L1_error); + __Pyx_INCREF((PyObject *)__pyx_v_outreallowerband); + __Pyx_GIVEREF((PyObject *)__pyx_v_outreallowerband); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outreallowerband)) != (0)) __PYX_ERR(4, 179, __pyx_L1_error); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.ACCBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_outrealupperband); + __Pyx_XDECREF((PyObject *)__pyx_v_outrealmiddleband); + __Pyx_XDECREF((PyObject *)__pyx_v_outreallowerband); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_21ACOS(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -12748,7 +7785,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ACOS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -12756,71 +7793,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 181, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 142, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ACOS") < 0)) __PYX_ERR(3, 142, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 181, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ACOS", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 142, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ACOS", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 181, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ACOS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 144, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_18ACOS(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 183, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_20ACOS(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_18ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_20ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -12832,42 +7863,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_18ACOS(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ACOS", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 161, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 162, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 163, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 163, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 202, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ACOS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 166, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 167, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 167, __pyx_L1_error) - __pyx_v_retCode = TA_ACOS(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ACOS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ACOS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 168, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ACOS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -12892,16 +7916,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_18ACOS(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_21AD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_23AD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_20AD, " AD(high, low, close, volume)\n\n Chaikin A/D Line (Volume Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close', 'volume']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_21AD = {"AD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_21AD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_20AD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_21AD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -12924,7 +7948,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("AD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -12932,72 +7956,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 210, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 210, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 210, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 210, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 171, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 171, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, 1); __PYX_ERR(3, 171, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 171, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, 2); __PYX_ERR(3, 171, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_volume)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 171, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, 3); __PYX_ERR(3, 171, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "AD") < 0)) __PYX_ERR(3, 171, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 210, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 210, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 210, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 210, __pyx_L3_error) } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); @@ -13006,42 +8004,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 171, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 210, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.AD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 173, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 173, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 173, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(3, 173, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_20AD(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 212, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 212, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 212, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 212, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_22AD(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_20AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume) { +static PyObject *__pyx_pf_5talib_7_ta_lib_22AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -13054,12 +8051,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_20AD(CYTHON_UNUSED PyObject *__pyx_sel __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -13069,53 +8061,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_20AD(CYTHON_UNUSED PyObject *__pyx_sel __Pyx_INCREF((PyObject *)__pyx_v_close); __Pyx_INCREF((PyObject *)__pyx_v_volume); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 190, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 191, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 192, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 193, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 194, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 195, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 195, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 195, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 195, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 195, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_AD_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 198, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 199, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 199, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 199, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 199, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 199, __pyx_L1_error) - __pyx_v_retCode = TA_AD(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_AD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 200, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -13143,16 +8126,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_20AD(CYTHON_UNUSED PyObject *__pyx_sel /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_23ADD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_25ADD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_22ADD, " ADD(real0, real1)\n\n Vector Arithmetic Add (Math Operators)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_23ADD = {"ADD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_23ADD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_22ADD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_23ADD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -13173,7 +8156,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ADD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -13181,86 +8164,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 242, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 242, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 203, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 203, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ADD", 1, 2, 2, 1); __PYX_ERR(3, 203, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ADD") < 0)) __PYX_ERR(3, 203, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 242, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 242, __pyx_L3_error) } __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ADD", 1, 2, 2, __pyx_nargs); __PYX_ERR(3, 203, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ADD", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 242, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ADD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 205, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 205, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_22ADD(__pyx_self, __pyx_v_real0, __pyx_v_real1); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 244, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 244, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_24ADD(__pyx_self, __pyx_v_real0, __pyx_v_real1); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_22ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { +static PyObject *__pyx_pf_5talib_7_ta_lib_24ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -13273,10 +8243,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_22ADD(CYTHON_UNUSED PyObject *__pyx_se __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -13284,39 +8251,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_22ADD(CYTHON_UNUSED PyObject *__pyx_se __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 223, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 224, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 225, __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_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 226, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 226, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 226, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ADD_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 229, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 230, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 230, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 230, __pyx_L1_error) - __pyx_v_retCode = TA_ADD(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ADD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 231, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -13342,16 +8304,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_22ADD(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_25ADOSC(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_27ADOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_24ADOSC, " ADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\n Chaikin A/D Oscillator (Volume Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close', 'volume']\n Parameters:\n fastperiod: 3\n slowperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_25ADOSC = {"ADOSC", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_25ADOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_24ADOSC}; -static PyObject *__pyx_pw_5talib_7_ta_lib_25ADOSC(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -13376,7 +8338,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ADOSC (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -13384,93 +8346,62 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 273, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 273, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 273, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 273, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 273, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 273, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 234, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 234, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, 1); __PYX_ERR(3, 234, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 234, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, 2); __PYX_ERR(3, 234, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_volume)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 234, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, 3); __PYX_ERR(3, 234, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 234, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 234, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ADOSC") < 0)) __PYX_ERR(3, 234, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 273, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 273, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 273, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 273, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 273, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 273, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -13480,54 +8411,53 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_close = ((PyArrayObject *)values[2]); __pyx_v_volume = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 236, __pyx_L3_error) + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 275, __pyx_L3_error) } else { __pyx_v_fastperiod = ((int)((int)-2147483648)); } if (values[5]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 236, __pyx_L3_error) + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 275, __pyx_L3_error) } else { __pyx_v_slowperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, __pyx_nargs); __PYX_ERR(3, 234, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, __pyx_nargs); __PYX_ERR(4, 273, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 236, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 236, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 236, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(3, 236, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_24ADOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_fastperiod, __pyx_v_slowperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 275, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 275, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 275, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 275, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_26ADOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_fastperiod, __pyx_v_slowperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_24ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_26ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -13540,12 +8470,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_24ADOSC(CYTHON_UNUSED PyObject *__pyx_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -13555,53 +8480,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_24ADOSC(CYTHON_UNUSED PyObject *__pyx_ __Pyx_INCREF((PyObject *)__pyx_v_close); __Pyx_INCREF((PyObject *)__pyx_v_volume); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 256, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 257, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 258, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 259, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 260, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 261, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 261, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 261, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 261, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 261, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ADOSC_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 264, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 265, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 265, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 265, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 265, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 265, __pyx_L1_error) - __pyx_v_retCode = TA_ADOSC(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ADOSC(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 266, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -13629,16 +8545,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_24ADOSC(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_27ADX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_29ADX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_26ADX, " ADX(high, low, close[, timeperiod=?])\n\n Average Directional Movement Index (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_27ADX = {"ADX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_27ADX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_26ADX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_27ADX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -13661,7 +8577,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ADX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -13669,69 +8585,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 308, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 308, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 308, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 308, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 269, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 269, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, 1); __PYX_ERR(3, 269, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 269, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, 2); __PYX_ERR(3, 269, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 269, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ADX") < 0)) __PYX_ERR(3, 269, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 308, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 308, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 308, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 308, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -13740,48 +8635,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 271, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 310, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, __pyx_nargs); __PYX_ERR(3, 269, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 308, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ADX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 271, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 271, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 271, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_26ADX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 310, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 310, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 310, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_28ADX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_26ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_28ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -13794,11 +8688,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_26ADX(CYTHON_UNUSED PyObject *__pyx_se __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -13807,46 +8697,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_26ADX(CYTHON_UNUSED PyObject *__pyx_se __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 290, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 291, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 292, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 293, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 294, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 294, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 294, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 294, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ADX_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 297, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 298, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 298, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 298, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 298, __pyx_L1_error) - __pyx_v_retCode = TA_ADX(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ADX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 299, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -13873,16 +8756,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_26ADX(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_29ADXR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_31ADXR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_28ADXR, " ADXR(high, low, close[, timeperiod=?])\n\n Average Directional Movement Index Rating (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_29ADXR = {"ADXR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_29ADXR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_28ADXR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_29ADXR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -13905,7 +8788,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ADXR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -13913,69 +8796,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 341, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 341, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 341, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 341, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 302, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 302, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, 1); __PYX_ERR(3, 302, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 302, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, 2); __PYX_ERR(3, 302, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 302, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ADXR") < 0)) __PYX_ERR(3, 302, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 341, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 341, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 341, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 341, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -13984,48 +8846,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 304, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 343, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, __pyx_nargs); __PYX_ERR(3, 302, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 341, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 304, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 304, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 304, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_28ADXR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 343, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 343, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 343, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_30ADXR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_28ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_30ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -14038,11 +8899,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_28ADXR(CYTHON_UNUSED PyObject *__pyx_s __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -14051,46 +8908,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_28ADXR(CYTHON_UNUSED PyObject *__pyx_s __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 323, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 324, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 363, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 325, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 364, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 326, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 327, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 327, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 327, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 327, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ADXR_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 330, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 331, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 331, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 331, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 331, __pyx_L1_error) - __pyx_v_retCode = TA_ADXR(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ADXR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADXR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 332, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADXR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -14117,16 +8967,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_28ADXR(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_31APO(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_33APO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_30APO, " APO(real[, fastperiod=?, slowperiod=?, matype=?])\n\n Absolute Price Oscillator (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_31APO = {"APO", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_31APO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_30APO}; -static PyObject *__pyx_pw_5talib_7_ta_lib_31APO(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -14149,7 +8999,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("APO (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -14157,121 +9007,107 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 374, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 374, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 374, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 374, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 335, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 335, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 335, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 335, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "APO") < 0)) __PYX_ERR(3, 335, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 374, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 374, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 374, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 374, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 337, __pyx_L3_error) + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 376, __pyx_L3_error) } else { __pyx_v_fastperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 337, __pyx_L3_error) + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 376, __pyx_L3_error) } else { __pyx_v_slowperiod = ((int)((int)-2147483648)); } if (values[3]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 337, __pyx_L3_error) + __pyx_v_matype = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 376, __pyx_L3_error) } else { __pyx_v_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("APO", 0, 1, 4, __pyx_nargs); __PYX_ERR(3, 335, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("APO", 0, 1, 4, __pyx_nargs); __PYX_ERR(4, 374, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.APO", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 337, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_30APO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 376, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_32APO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_30APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_32APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -14283,42 +9119,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_30APO(CYTHON_UNUSED PyObject *__pyx_se PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("APO", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 358, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 359, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 360, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 360, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 399, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_APO_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 363, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 402, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 364, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 364, __pyx_L1_error) - __pyx_v_retCode = TA_APO(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_APO(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_APO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 365, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_APO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -14343,16 +9172,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_30APO(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_33AROON(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_35AROON(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_32AROON, " AROON(high, low[, timeperiod=?])\n\n Aroon (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n aroondown\n aroonup\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_33AROON = {"AROON", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_33AROON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_32AROON}; -static PyObject *__pyx_pw_5talib_7_ta_lib_33AROON(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -14374,7 +9203,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("AROON (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -14382,56 +9211,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 407, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 407, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 407, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 368, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 368, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("AROON", 0, 2, 3, 1); __PYX_ERR(3, 368, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 368, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "AROON") < 0)) __PYX_ERR(3, 368, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 407, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 407, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 407, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -14439,47 +9254,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 370, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 409, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("AROON", 0, 2, 3, __pyx_nargs); __PYX_ERR(3, 368, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("AROON", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 407, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.AROON", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 370, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 370, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_32AROON(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 409, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 409, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_34AROON(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_32AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_34AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -14493,11 +9307,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_32AROON(CYTHON_UNUSED PyObject *__pyx_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -14505,57 +9315,51 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_32AROON(CYTHON_UNUSED PyObject *__pyx_ __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 391, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 392, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 393, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 394, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 394, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 394, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_AROON_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 397, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outaroondown = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 398, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outaroonup = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 399, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 399, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outaroondown); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 399, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outaroonup); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 399, __pyx_L1_error) - __pyx_v_retCode = TA_AROON(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_AROON(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outaroondown)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outaroonup)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AROON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 400, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AROON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 401, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 440, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outaroondown); __Pyx_GIVEREF((PyObject *)__pyx_v_outaroondown); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outaroondown))) __PYX_ERR(3, 401, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outaroondown)) != (0)) __PYX_ERR(4, 440, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outaroonup); __Pyx_GIVEREF((PyObject *)__pyx_v_outaroonup); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outaroonup))) __PYX_ERR(3, 401, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outaroonup)) != (0)) __PYX_ERR(4, 440, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -14578,16 +9382,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_32AROON(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_35AROONOSC(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_37AROONOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_34AROONOSC, " AROONOSC(high, low[, timeperiod=?])\n\n Aroon Oscillator (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_35AROONOSC = {"AROONOSC", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_35AROONOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_34AROONOSC}; -static PyObject *__pyx_pw_5talib_7_ta_lib_35AROONOSC(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -14609,7 +9413,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("AROONOSC (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -14617,56 +9421,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 442, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 442, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 442, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 403, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 403, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("AROONOSC", 0, 2, 3, 1); __PYX_ERR(3, 403, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 403, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "AROONOSC") < 0)) __PYX_ERR(3, 403, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 442, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 442, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 442, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -14674,47 +9464,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 405, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 444, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("AROONOSC", 0, 2, 3, __pyx_nargs); __PYX_ERR(3, 403, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("AROONOSC", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 442, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 405, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 405, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_34AROONOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 444, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 444, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_36AROONOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_34AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_36AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -14727,10 +9516,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_34AROONOSC(CYTHON_UNUSED PyObject *__p __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -14738,39 +9524,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_34AROONOSC(CYTHON_UNUSED PyObject *__p __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 424, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 463, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 425, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 464, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 426, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 427, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 427, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 427, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_AROONOSC_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 430, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 431, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 431, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 431, __pyx_L1_error) - __pyx_v_retCode = TA_AROONOSC(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_AROONOSC(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AROONOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 432, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AROONOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -14796,16 +9577,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_34AROONOSC(CYTHON_UNUSED PyObject *__p /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_37ASIN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_39ASIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_36ASIN, " ASIN(real)\n\n Vector Trigonometric ASin (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_37ASIN = {"ASIN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_37ASIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_36ASIN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_37ASIN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -14825,7 +9606,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ASIN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -14833,71 +9614,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 474, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 435, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ASIN") < 0)) __PYX_ERR(3, 435, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 474, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ASIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 435, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ASIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 474, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ASIN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 437, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_36ASIN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 476, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_38ASIN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_36ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_38ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -14909,42 +9684,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_36ASIN(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ASIN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 454, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 455, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 456, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 456, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 495, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ASIN_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 459, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 460, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 460, __pyx_L1_error) - __pyx_v_retCode = TA_ASIN(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ASIN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ASIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 461, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ASIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -14969,16 +9737,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_36ASIN(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_39ATAN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_41ATAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_38ATAN, " ATAN(real)\n\n Vector Trigonometric ATan (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_39ATAN = {"ATAN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_39ATAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_38ATAN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_39ATAN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -14998,7 +9766,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ATAN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -15006,71 +9774,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 503, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 464, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ATAN") < 0)) __PYX_ERR(3, 464, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 503, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ATAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 464, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ATAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 503, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ATAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 466, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_38ATAN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 505, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_40ATAN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_38ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_40ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -15082,42 +9844,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_38ATAN(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ATAN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 483, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 484, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 485, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 485, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 524, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ATAN_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 488, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 489, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 489, __pyx_L1_error) - __pyx_v_retCode = TA_ATAN(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ATAN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ATAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 490, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ATAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -15142,16 +9897,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_38ATAN(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_41ATR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_43ATR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_40ATR, " ATR(high, low, close[, timeperiod=?])\n\n Average True Range (Volatility Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_41ATR = {"ATR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_41ATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_40ATR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_41ATR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -15174,7 +9929,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ATR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -15182,69 +9937,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 532, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 532, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 532, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 532, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 493, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 493, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, 1); __PYX_ERR(3, 493, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 493, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, 2); __PYX_ERR(3, 493, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 493, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ATR") < 0)) __PYX_ERR(3, 493, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 532, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 532, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 532, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 532, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -15253,48 +9987,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 495, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 534, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(3, 493, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 532, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ATR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 495, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 495, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 495, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_40ATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 534, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 534, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 534, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_42ATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_40ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_42ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -15307,11 +10040,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_40ATR(CYTHON_UNUSED PyObject *__pyx_se __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -15320,46 +10049,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_40ATR(CYTHON_UNUSED PyObject *__pyx_se __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 514, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 515, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 516, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 517, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 518, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 518, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 518, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 518, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ATR_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 521, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 522, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 522, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 522, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 522, __pyx_L1_error) - __pyx_v_retCode = TA_ATR(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ATR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 523, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 562, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -15386,16 +10108,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_40ATR(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_43AVGPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_45AVGPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_42AVGPRICE, " AVGPRICE(open, high, low, close)\n\n Average Price (Price Transform)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_43AVGPRICE = {"AVGPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_43AVGPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_42AVGPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_43AVGPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -15418,7 +10140,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("AVGPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -15426,72 +10148,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 565, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 526, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 526, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, 1); __PYX_ERR(3, 526, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 526, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, 2); __PYX_ERR(3, 526, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 526, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, 3); __PYX_ERR(3, 526, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "AVGPRICE") < 0)) __PYX_ERR(3, 526, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 565, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 565, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 565, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 565, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -15500,42 +10196,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 526, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 565, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 528, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 528, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 528, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 528, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_42AVGPRICE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 567, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 567, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 567, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 567, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_44AVGPRICE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_44AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -15548,12 +10243,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__p __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -15563,53 +10253,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__p __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 545, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 584, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 546, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 547, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 548, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 587, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 549, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 550, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 550, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 550, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 550, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 550, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_AVGPRICE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 553, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 554, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 554, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 554, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 554, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 554, __pyx_L1_error) - __pyx_v_retCode = TA_AVGPRICE(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_AVGPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AVGPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 555, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AVGPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -15637,16 +10318,193 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__p /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_45BBANDS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_47AVGDEV(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_real = 0; + int __pyx_v_timeperiod; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("AVGDEV (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__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(4, 597, __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(4, 597, __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, "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) } + } + } else { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 597, __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(4, 597, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 599, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("AVGDEV", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 597, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.AVGDEV", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 599, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_46AVGDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_46AVGDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { + npy_intp __pyx_v_length; + int __pyx_v_begidx; + int __pyx_v_endidx; + int __pyx_v_lookback; + TA_RetCode __pyx_v_retCode; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + PyArrayObject *__pyx_v_outreal = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("AVGDEV", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); + + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 620, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; + + __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); + + __pyx_v_lookback = (__pyx_v_begidx + TA_AVGDEV_Lookback(__pyx_v_timeperiod)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + __pyx_v_retCode = TA_AVGDEV(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AVGDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_outreal); + __pyx_r = ((PyObject *)__pyx_v_outreal); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.AVGDEV", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_outreal); + __Pyx_XDECREF((PyObject *)__pyx_v_real); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_49BBANDS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_44BBANDS, " BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\n Bollinger Bands (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 5\n nbdevup: 2.0\n nbdevdn: 2.0\n matype: 0 (Simple Moving Average)\n Outputs:\n upperband\n middleband\n lowerband\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_45BBANDS = {"BBANDS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_45BBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_44BBANDS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_45BBANDS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -15670,7 +10528,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("BBANDS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -15678,137 +10536,120 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdevup,&__pyx_n_s_nbdevdn,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 628, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 628, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 628, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 628, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 628, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 558, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 558, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nbdevup); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 558, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nbdevdn); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 558, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 558, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "BBANDS") < 0)) __PYX_ERR(3, 558, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 628, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 628, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 628, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 628, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 628, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 560, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 630, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_nbdevup = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdevup == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 560, __pyx_L3_error) + __pyx_v_nbdevup = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdevup == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 630, __pyx_L3_error) } else { __pyx_v_nbdevup = ((double)((double)-4e37)); } if (values[3]) { - __pyx_v_nbdevdn = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_nbdevdn == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 560, __pyx_L3_error) + __pyx_v_nbdevdn = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_nbdevdn == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 630, __pyx_L3_error) } else { __pyx_v_nbdevdn = ((double)((double)-4e37)); } if (values[4]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 560, __pyx_L3_error) + __pyx_v_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 630, __pyx_L3_error) } else { __pyx_v_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("BBANDS", 0, 1, 5, __pyx_nargs); __PYX_ERR(3, 558, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("BBANDS", 0, 1, 5, __pyx_nargs); __PYX_ERR(4, 628, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 560, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_44BBANDS(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 630, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_48BBANDS(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_44BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_48BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -15822,71 +10663,60 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_44BBANDS(CYTHON_UNUSED PyObject *__pyx PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("BBANDS", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 586, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 587, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 588, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 588, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 658, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_BBANDS_Lookback(__pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 591, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outrealupperband = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 592, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 662, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outrealmiddleband = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 593, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreallowerband = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 594, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealupperband); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 594, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealmiddleband); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 594, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreallowerband); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 594, __pyx_L1_error) - __pyx_v_retCode = TA_BBANDS(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback), (((double *)__pyx_t_6) + __pyx_v_lookback), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_BBANDS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealupperband)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealmiddleband)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreallowerband)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 595, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 665, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 596, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 666, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outrealupperband); __Pyx_GIVEREF((PyObject *)__pyx_v_outrealupperband); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outrealupperband))) __PYX_ERR(3, 596, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outrealupperband)) != (0)) __PYX_ERR(4, 666, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outrealmiddleband); __Pyx_GIVEREF((PyObject *)__pyx_v_outrealmiddleband); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outrealmiddleband))) __PYX_ERR(3, 596, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outrealmiddleband)) != (0)) __PYX_ERR(4, 666, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outreallowerband); __Pyx_GIVEREF((PyObject *)__pyx_v_outreallowerband); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outreallowerband))) __PYX_ERR(3, 596, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outreallowerband)) != (0)) __PYX_ERR(4, 666, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -15909,16 +10739,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_44BBANDS(CYTHON_UNUSED PyObject *__pyx /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_47BETA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_51BETA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_46BETA, " BETA(real0, real1[, timeperiod=?])\n\n Beta (Statistic Functions)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Parameters:\n timeperiod: 5\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_47BETA = {"BETA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_47BETA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_46BETA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_47BETA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -15940,7 +10770,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("BETA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -15948,56 +10778,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 668, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 668, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 668, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 598, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 598, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("BETA", 0, 2, 3, 1); __PYX_ERR(3, 598, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 598, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "BETA") < 0)) __PYX_ERR(3, 598, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 668, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 668, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 668, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -16005,47 +10821,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 600, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 670, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("BETA", 0, 2, 3, __pyx_nargs); __PYX_ERR(3, 598, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("BETA", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 668, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.BETA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 600, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 600, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_46BETA(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 670, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 670, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_50BETA(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_50BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -16058,10 +10873,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_s __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -16069,39 +10881,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_s __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 620, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 690, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 621, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 622, __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_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 623, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 623, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 623, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_BETA_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 626, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 696, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 627, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 627, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 627, __pyx_L1_error) - __pyx_v_retCode = TA_BETA(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_BETA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BETA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 628, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BETA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -16127,16 +10934,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_49BOP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_53BOP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_48BOP, " BOP(open, high, low, close)\n\n Balance Of Power (Momentum Indicators)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_49BOP = {"BOP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_49BOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_48BOP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_49BOP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -16159,7 +10966,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("BOP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -16167,72 +10974,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 701, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 701, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 701, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 701, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 631, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 631, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, 1); __PYX_ERR(3, 631, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 631, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, 2); __PYX_ERR(3, 631, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 631, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, 3); __PYX_ERR(3, 631, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "BOP") < 0)) __PYX_ERR(3, 631, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 701, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 701, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 701, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 701, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -16241,42 +11022,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 631, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 701, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.BOP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 633, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 633, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 633, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 633, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_48BOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 703, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 703, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 703, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 703, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_52BOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_52BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -16289,12 +11069,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_se __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -16304,53 +11079,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_se __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 650, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 720, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 651, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 652, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 722, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 653, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 723, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 654, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 655, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 655, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 655, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 655, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 655, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_BOP_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 658, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 728, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 659, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 659, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 659, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 659, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 659, __pyx_L1_error) - __pyx_v_retCode = TA_BOP(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_BOP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 660, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 730, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -16378,16 +11144,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_51CCI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_55CCI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_50CCI, " CCI(high, low, close[, timeperiod=?])\n\n Commodity Channel Index (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_51CCI = {"CCI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_51CCI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_50CCI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_51CCI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -16410,7 +11176,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CCI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -16418,69 +11184,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 733, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 733, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 733, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 733, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 663, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 663, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, 1); __PYX_ERR(3, 663, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 663, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, 2); __PYX_ERR(3, 663, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 663, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CCI") < 0)) __PYX_ERR(3, 663, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 733, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 733, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 733, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 733, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -16489,48 +11234,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 665, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 735, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, __pyx_nargs); __PYX_ERR(3, 663, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 733, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CCI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 665, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 665, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 665, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_50CCI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 735, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 735, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 735, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_54CCI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_54CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -16543,11 +11287,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_se __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -16556,46 +11296,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_se __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 684, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 685, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 686, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 687, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 688, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 688, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 688, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 688, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CCI_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 691, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 692, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 692, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 692, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 692, __pyx_L1_error) - __pyx_v_retCode = TA_CCI(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CCI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CCI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 693, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CCI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -16622,16 +11355,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_53CDL2CROWS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_57CDL2CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_52CDL2CROWS, " CDL2CROWS(open, high, low, close)\n\n Two Crows (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_53CDL2CROWS = {"CDL2CROWS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_53CDL2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_52CDL2CROWS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_53CDL2CROWS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -16654,7 +11387,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDL2CROWS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -16662,72 +11395,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 766, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 766, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 766, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 766, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 696, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 696, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, 1); __PYX_ERR(3, 696, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 696, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, 2); __PYX_ERR(3, 696, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 696, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, 3); __PYX_ERR(3, 696, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDL2CROWS") < 0)) __PYX_ERR(3, 696, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 766, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 766, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 766, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 766, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -16736,42 +11443,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 696, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 766, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 698, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 698, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 698, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 698, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_52CDL2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 768, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 768, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 768, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 768, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_56CDL2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_52CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -16784,12 +11490,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_52CDL2CROWS(CYTHON_UNUSED PyObject *__ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -16799,53 +11500,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_52CDL2CROWS(CYTHON_UNUSED PyObject *__ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 715, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 716, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 717, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 718, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 719, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 720, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 720, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 720, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 720, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 720, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDL2CROWS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 723, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 724, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 724, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 724, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 724, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 724, __pyx_L1_error) - __pyx_v_retCode = TA_CDL2CROWS(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDL2CROWS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 725, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -16873,16 +11565,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_52CDL2CROWS(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_55CDL3BLACKCROWS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_59CDL3BLACKCROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_54CDL3BLACKCROWS, " CDL3BLACKCROWS(open, high, low, close)\n\n Three Black Crows (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_55CDL3BLACKCROWS = {"CDL3BLACKCROWS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_55CDL3BLACKCROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_54CDL3BLACKCROWS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_55CDL3BLACKCROWS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -16905,7 +11597,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDL3BLACKCROWS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -16913,72 +11605,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 798, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 798, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 798, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 798, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 728, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 728, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, 1); __PYX_ERR(3, 728, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 728, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, 2); __PYX_ERR(3, 728, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 728, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, 3); __PYX_ERR(3, 728, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDL3BLACKCROWS") < 0)) __PYX_ERR(3, 728, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 798, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 798, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 798, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 798, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -16987,42 +11653,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 728, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 798, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 730, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 730, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 730, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 730, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 800, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 800, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 800, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 800, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_58CDL3BLACKCROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -17035,12 +11700,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(CYTHON_UNUSED PyObjec __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -17050,53 +11710,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(CYTHON_UNUSED PyObjec __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 747, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 748, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 749, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 750, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 751, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 752, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 752, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 752, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 752, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 752, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3BLACKCROWS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 755, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 756, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 756, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 756, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 756, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 756, __pyx_L1_error) - __pyx_v_retCode = TA_CDL3BLACKCROWS(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDL3BLACKCROWS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3BLACKCROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 757, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3BLACKCROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 827, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -17124,16 +11775,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_57CDL3INSIDE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_61CDL3INSIDE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_56CDL3INSIDE, " CDL3INSIDE(open, high, low, close)\n\n Three Inside Up/Down (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_57CDL3INSIDE = {"CDL3INSIDE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_57CDL3INSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_56CDL3INSIDE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_57CDL3INSIDE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -17156,7 +11807,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDL3INSIDE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -17164,72 +11815,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 830, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 830, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 830, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 830, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 760, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 760, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, 1); __PYX_ERR(3, 760, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 760, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, 2); __PYX_ERR(3, 760, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 760, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, 3); __PYX_ERR(3, 760, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDL3INSIDE") < 0)) __PYX_ERR(3, 760, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 830, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 830, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 830, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 830, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -17238,42 +11863,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 760, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 830, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 762, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 762, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 762, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 762, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 832, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 832, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 832, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 832, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_60CDL3INSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -17286,12 +11910,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(CYTHON_UNUSED PyObject *_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -17301,53 +11920,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(CYTHON_UNUSED PyObject *_ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 779, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 780, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 850, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 781, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 782, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 783, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 784, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 784, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 784, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 784, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 784, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3INSIDE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 787, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 788, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 788, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 788, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 788, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 788, __pyx_L1_error) - __pyx_v_retCode = TA_CDL3INSIDE(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDL3INSIDE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3INSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 789, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3INSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 859, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -17375,16 +11985,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_59CDL3LINESTRIKE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_63CDL3LINESTRIKE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_58CDL3LINESTRIKE, " CDL3LINESTRIKE(open, high, low, close)\n\n Three-Line Strike (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_59CDL3LINESTRIKE = {"CDL3LINESTRIKE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_59CDL3LINESTRIKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_58CDL3LINESTRIKE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_59CDL3LINESTRIKE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -17407,7 +12017,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDL3LINESTRIKE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -17415,72 +12025,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 862, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 862, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 862, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 862, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 792, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 792, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, 1); __PYX_ERR(3, 792, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 792, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, 2); __PYX_ERR(3, 792, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 792, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, 3); __PYX_ERR(3, 792, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDL3LINESTRIKE") < 0)) __PYX_ERR(3, 792, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 862, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 862, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 862, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 862, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -17489,42 +12073,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 792, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 862, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 794, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 794, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 794, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 794, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 864, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 864, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 864, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 864, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_62CDL3LINESTRIKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -17537,12 +12120,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(CYTHON_UNUSED PyObjec __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -17552,53 +12130,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(CYTHON_UNUSED PyObjec __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 811, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 812, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 813, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 814, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 815, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 816, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 816, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 816, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 816, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 816, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3LINESTRIKE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 819, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 820, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 820, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 820, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 820, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 820, __pyx_L1_error) - __pyx_v_retCode = TA_CDL3LINESTRIKE(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDL3LINESTRIKE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3LINESTRIKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 821, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3LINESTRIKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -17626,16 +12195,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_61CDL3OUTSIDE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_65CDL3OUTSIDE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_60CDL3OUTSIDE, " CDL3OUTSIDE(open, high, low, close)\n\n Three Outside Up/Down (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_61CDL3OUTSIDE = {"CDL3OUTSIDE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_61CDL3OUTSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_60CDL3OUTSIDE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_61CDL3OUTSIDE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -17658,7 +12227,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDL3OUTSIDE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -17666,72 +12235,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 894, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 894, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 894, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 894, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 824, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 824, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, 1); __PYX_ERR(3, 824, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 824, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, 2); __PYX_ERR(3, 824, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 824, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, 3); __PYX_ERR(3, 824, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDL3OUTSIDE") < 0)) __PYX_ERR(3, 824, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 894, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 894, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 894, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 894, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -17740,42 +12283,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 824, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 894, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 826, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 826, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 826, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 826, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 896, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 896, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 896, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 896, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_64CDL3OUTSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -17788,12 +12330,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(CYTHON_UNUSED PyObject * __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -17803,53 +12340,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 843, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 844, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 845, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 915, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 846, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 916, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 847, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 848, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 848, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 848, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 848, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 848, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3OUTSIDE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 851, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 852, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 852, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 852, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 852, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 852, __pyx_L1_error) - __pyx_v_retCode = TA_CDL3OUTSIDE(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDL3OUTSIDE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3OUTSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 853, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3OUTSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 923, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -17877,16 +12405,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_63CDL3STARSINSOUTH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_67CDL3STARSINSOUTH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_62CDL3STARSINSOUTH, " CDL3STARSINSOUTH(open, high, low, close)\n\n Three Stars In The South (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_63CDL3STARSINSOUTH = {"CDL3STARSINSOUTH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_63CDL3STARSINSOUTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_62CDL3STARSINSOUTH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_63CDL3STARSINSOUTH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -17909,7 +12437,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDL3STARSINSOUTH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -17917,72 +12445,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 926, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 926, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 926, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 926, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 856, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 856, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, 1); __PYX_ERR(3, 856, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 856, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, 2); __PYX_ERR(3, 856, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 856, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, 3); __PYX_ERR(3, 856, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDL3STARSINSOUTH") < 0)) __PYX_ERR(3, 856, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 926, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 926, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 926, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 926, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -17991,42 +12493,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 856, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 926, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 858, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 858, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 858, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 858, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 928, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 928, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 928, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 928, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_66CDL3STARSINSOUTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_66CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -18039,12 +12540,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(CYTHON_UNUSED PyObj __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -18054,53 +12550,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 875, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 876, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 946, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 877, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 947, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 878, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 948, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 879, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 880, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 880, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 880, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 880, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 880, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3STARSINSOUTH_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 883, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 953, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 884, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 884, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 884, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 884, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 884, __pyx_L1_error) - __pyx_v_retCode = TA_CDL3STARSINSOUTH(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDL3STARSINSOUTH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3STARSINSOUTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 885, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3STARSINSOUTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 955, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -18128,16 +12615,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_65CDL3WHITESOLDIERS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_69CDL3WHITESOLDIERS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_64CDL3WHITESOLDIERS, " CDL3WHITESOLDIERS(open, high, low, close)\n\n Three Advancing White Soldiers (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_65CDL3WHITESOLDIERS = {"CDL3WHITESOLDIERS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_65CDL3WHITESOLDIERS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_64CDL3WHITESOLDIERS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_65CDL3WHITESOLDIERS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -18160,7 +12647,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDL3WHITESOLDIERS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -18168,72 +12655,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 958, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 958, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 958, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 958, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 888, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 888, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, 1); __PYX_ERR(3, 888, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 888, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, 2); __PYX_ERR(3, 888, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 888, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, 3); __PYX_ERR(3, 888, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDL3WHITESOLDIERS") < 0)) __PYX_ERR(3, 888, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 958, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 958, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 958, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 958, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -18242,42 +12703,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 888, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 958, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 890, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 890, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 890, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 890, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 960, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 960, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 960, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 960, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_68CDL3WHITESOLDIERS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_68CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -18290,12 +12750,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(CYTHON_UNUSED PyOb __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -18305,53 +12760,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(CYTHON_UNUSED PyOb __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 907, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 977, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 908, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 978, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 909, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 910, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 980, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 911, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 912, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 912, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 912, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 912, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 912, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3WHITESOLDIERS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 915, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 916, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 916, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 916, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 916, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 916, __pyx_L1_error) - __pyx_v_retCode = TA_CDL3WHITESOLDIERS(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDL3WHITESOLDIERS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3WHITESOLDIERS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 917, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3WHITESOLDIERS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 987, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -18379,16 +12825,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_67CDLABANDONEDBABY(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_71CDLABANDONEDBABY(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_66CDLABANDONEDBABY, " CDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\n Abandoned Baby (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_67CDLABANDONEDBABY = {"CDLABANDONEDBABY", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_67CDLABANDONEDBABY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_66CDLABANDONEDBABY}; -static PyObject *__pyx_pw_5talib_7_ta_lib_67CDLABANDONEDBABY(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -18412,7 +12858,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLABANDONEDBABY (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -18420,82 +12866,54 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 990, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 990, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 990, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 990, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 990, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 920, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 920, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, 1); __PYX_ERR(3, 920, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 920, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, 2); __PYX_ERR(3, 920, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 920, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, 3); __PYX_ERR(3, 920, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 920, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLABANDONEDBABY") < 0)) __PYX_ERR(3, 920, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 990, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 990, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 990, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 990, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 990, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -18505,49 +12923,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 922, __pyx_L3_error) + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 992, __pyx_L3_error) } else { __pyx_v_penetration = ((double)((double)0.3)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, __pyx_nargs); __PYX_ERR(3, 920, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 990, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 922, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 922, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 922, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 922, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 992, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 992, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 992, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 992, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_70CDLABANDONEDBABY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -18560,12 +12977,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(CYTHON_UNUSED PyObj __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -18575,53 +12987,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 941, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1011, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 942, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 943, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 944, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1014, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 945, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 946, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 946, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 946, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 946, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 946, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLABANDONEDBABY_Lookback(__pyx_v_penetration)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 949, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1019, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 950, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 950, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 950, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 950, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 950, __pyx_L1_error) - __pyx_v_retCode = TA_CDLABANDONEDBABY(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLABANDONEDBABY(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLABANDONEDBABY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 951, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLABANDONEDBABY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1021, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -18649,16 +13052,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_69CDLADVANCEBLOCK(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_73CDLADVANCEBLOCK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_68CDLADVANCEBLOCK, " CDLADVANCEBLOCK(open, high, low, close)\n\n Advance Block (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_69CDLADVANCEBLOCK = {"CDLADVANCEBLOCK", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_69CDLADVANCEBLOCK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_68CDLADVANCEBLOCK}; -static PyObject *__pyx_pw_5talib_7_ta_lib_69CDLADVANCEBLOCK(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -18681,7 +13084,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLADVANCEBLOCK (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -18689,72 +13092,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1024, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1024, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1024, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1024, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 954, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 954, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, 1); __PYX_ERR(3, 954, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 954, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, 2); __PYX_ERR(3, 954, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 954, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, 3); __PYX_ERR(3, 954, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLADVANCEBLOCK") < 0)) __PYX_ERR(3, 954, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1024, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1024, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1024, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1024, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -18763,42 +13140,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 954, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1024, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 956, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 956, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 956, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 956, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1026, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1026, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1026, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1026, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_72CDLADVANCEBLOCK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -18811,12 +13187,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(CYTHON_UNUSED PyObje __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -18826,53 +13197,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(CYTHON_UNUSED PyObje __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 973, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1043, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 974, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 975, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1045, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 976, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 977, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 978, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 978, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 978, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 978, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 978, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLADVANCEBLOCK_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 981, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1051, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 982, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 982, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 982, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 982, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 982, __pyx_L1_error) - __pyx_v_retCode = TA_CDLADVANCEBLOCK(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLADVANCEBLOCK(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLADVANCEBLOCK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 983, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLADVANCEBLOCK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1053, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -18900,16 +13262,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_71CDLBELTHOLD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_75CDLBELTHOLD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_70CDLBELTHOLD, " CDLBELTHOLD(open, high, low, close)\n\n Belt-hold (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_71CDLBELTHOLD = {"CDLBELTHOLD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_71CDLBELTHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_70CDLBELTHOLD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_71CDLBELTHOLD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -18932,7 +13294,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLBELTHOLD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -18940,72 +13302,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1056, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1056, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1056, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1056, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 986, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 986, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, 1); __PYX_ERR(3, 986, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 986, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, 2); __PYX_ERR(3, 986, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 986, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, 3); __PYX_ERR(3, 986, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLBELTHOLD") < 0)) __PYX_ERR(3, 986, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1056, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1056, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1056, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1056, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -19014,42 +13350,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 986, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1056, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 988, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 988, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 988, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 988, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1058, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1058, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1058, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1058, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_74CDLBELTHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -19062,12 +13397,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(CYTHON_UNUSED PyObject * __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -19077,53 +13407,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1005, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1006, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1076, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1007, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1077, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1008, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1078, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1009, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1010, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1010, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1010, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1010, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1010, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLBELTHOLD_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1013, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1083, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1014, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1014, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1014, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1014, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1014, __pyx_L1_error) - __pyx_v_retCode = TA_CDLBELTHOLD(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLBELTHOLD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLBELTHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1015, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLBELTHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1085, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -19151,16 +13472,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_73CDLBREAKAWAY(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_77CDLBREAKAWAY(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_72CDLBREAKAWAY, " CDLBREAKAWAY(open, high, low, close)\n\n Breakaway (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_73CDLBREAKAWAY = {"CDLBREAKAWAY", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_73CDLBREAKAWAY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_72CDLBREAKAWAY}; -static PyObject *__pyx_pw_5talib_7_ta_lib_73CDLBREAKAWAY(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -19183,7 +13504,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLBREAKAWAY (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -19191,72 +13512,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1088, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1088, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1088, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1088, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1018, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1018, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, 1); __PYX_ERR(3, 1018, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1018, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, 2); __PYX_ERR(3, 1018, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1018, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, 3); __PYX_ERR(3, 1018, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLBREAKAWAY") < 0)) __PYX_ERR(3, 1018, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1088, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1088, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1088, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1088, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -19265,42 +13560,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1018, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1088, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1020, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1020, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1020, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1020, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1090, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1090, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1090, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1090, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_76CDLBREAKAWAY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -19313,12 +13607,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(CYTHON_UNUSED PyObject __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -19328,53 +13617,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1037, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1038, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1039, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1040, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1041, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1042, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1042, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1042, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1042, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1042, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLBREAKAWAY_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1045, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1046, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1046, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1046, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1046, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1046, __pyx_L1_error) - __pyx_v_retCode = TA_CDLBREAKAWAY(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLBREAKAWAY(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLBREAKAWAY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1047, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLBREAKAWAY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -19402,16 +13682,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU, " CDLCLOSINGMARUBOZU(open, high, low, close)\n\n Closing Marubozu (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU = {"CDLCLOSINGMARUBOZU", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU}; -static PyObject *__pyx_pw_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -19434,7 +13714,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLCLOSINGMARUBOZU (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -19442,72 +13722,256 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1120, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1120, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1120, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1120, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1120, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1120, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1120, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1120, __pyx_L3_error) + } + __pyx_v_open = ((PyArrayObject *)values[0]); + __pyx_v_high = ((PyArrayObject *)values[1]); + __pyx_v_low = ((PyArrayObject *)values[2]); + __pyx_v_close = ((PyArrayObject *)values[3]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1120, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1122, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1122, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1122, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1122, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { + npy_intp __pyx_v_length; + int __pyx_v_begidx; + int __pyx_v_endidx; + int __pyx_v_lookback; + TA_RetCode __pyx_v_retCode; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + PyArrayObject *__pyx_v_outinteger = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_intp __pyx_t_2; + npy_int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("CDLCLOSINGMARUBOZU", 0); + __Pyx_INCREF((PyObject *)__pyx_v_open); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __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)-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) + __pyx_v_begidx = __pyx_t_3; + + __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); + + __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCLOSINGMARUBOZU_Lookback()); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + __pyx_v_retCode = TA_CDLCLOSINGMARUBOZU(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCLOSINGMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_outinteger); + __pyx_r = ((PyObject *)__pyx_v_outinteger); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_outinteger); + __Pyx_XDECREF((PyObject *)__pyx_v_open); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_81CDLCONCEALBABYSWALL(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_open = 0; + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("CDLCONCEALBABYSWALL (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1050, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1152, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1050, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, 1); __PYX_ERR(3, 1050, __pyx_L3_error) - } + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1152, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1050, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, 2); __PYX_ERR(3, 1050, __pyx_L3_error) - } + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1152, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1050, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, 3); __PYX_ERR(3, 1050, __pyx_L3_error) - } + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1152, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLCLOSINGMARUBOZU") < 0)) __PYX_ERR(3, 1050, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1152, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1152, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1152, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1152, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -19516,42 +13980,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1050, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1152, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1052, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1052, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1052, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1052, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1154, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1154, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1154, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1154, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_80CDLCONCEALBABYSWALL(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -19564,319 +14027,54 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyO __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("CDLCLOSINGMARUBOZU", 0); + __Pyx_RefNannySetupContext("CDLCONCEALBABYSWALL", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1069, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1070, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1071, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1173, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1072, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1174, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1073, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1074, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1074, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1074, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1074, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1074, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; - - __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - - __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCLOSINGMARUBOZU_Lookback()); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1077, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; - - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1078, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1078, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1078, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1078, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1078, __pyx_L1_error) - __pyx_v_retCode = TA_CDLCLOSINGMARUBOZU(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); - - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCLOSINGMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1079, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_outinteger); - __pyx_r = ((PyObject *)__pyx_v_outinteger); - goto __pyx_L0; - - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_outinteger); - __Pyx_XDECREF((PyObject *)__pyx_v_open); - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); - __Pyx_XDECREF((PyObject *)__pyx_v_close); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - - -/* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_77CDLCONCEALBABYSWALL(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_76CDLCONCEALBABYSWALL, " CDLCONCEALBABYSWALL(open, high, low, close)\n\n Concealing Baby Swallow (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_77CDLCONCEALBABYSWALL = {"CDLCONCEALBABYSWALL", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_77CDLCONCEALBABYSWALL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_76CDLCONCEALBABYSWALL}; -static PyObject *__pyx_pw_5talib_7_ta_lib_77CDLCONCEALBABYSWALL(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyArrayObject *__pyx_v_open = 0; - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; - PyArrayObject *__pyx_v_close = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("CDLCONCEALBABYSWALL (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1082, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1082, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, 1); __PYX_ERR(3, 1082, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1082, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, 2); __PYX_ERR(3, 1082, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1082, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, 3); __PYX_ERR(3, 1082, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLCONCEALBABYSWALL") < 0)) __PYX_ERR(3, 1082, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - } - __pyx_v_open = ((PyArrayObject *)values[0]); - __pyx_v_high = ((PyArrayObject *)values[1]); - __pyx_v_low = ((PyArrayObject *)values[2]); - __pyx_v_close = ((PyArrayObject *)values[3]); - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1082, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("talib._ta_lib.CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1084, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1084, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1084, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1084, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_76CDLCONCEALBABYSWALL(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { - npy_intp __pyx_v_length; - int __pyx_v_begidx; - int __pyx_v_endidx; - int __pyx_v_lookback; - TA_RetCode __pyx_v_retCode; - int __pyx_v_outbegidx; - int __pyx_v_outnbelement; - PyArrayObject *__pyx_v_outinteger = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("CDLCONCEALBABYSWALL", 0); - __Pyx_INCREF((PyObject *)__pyx_v_open); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - __Pyx_INCREF((PyObject *)__pyx_v_close); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __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(3, 1105, __pyx_L1_error) - __pyx_v_length = __pyx_t_2; - - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1106, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1106, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1106, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1106, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1106, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCONCEALBABYSWALL_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1109, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1110, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1110, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1110, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1110, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1110, __pyx_L1_error) - __pyx_v_retCode = TA_CDLCONCEALBABYSWALL(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLCONCEALBABYSWALL(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCONCEALBABYSWALL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1111, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCONCEALBABYSWALL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -19904,16 +14102,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLCONCEALBABYSWALL(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_79CDLCOUNTERATTACK(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_83CDLCOUNTERATTACK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_78CDLCOUNTERATTACK, " CDLCOUNTERATTACK(open, high, low, close)\n\n Counterattack (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_79CDLCOUNTERATTACK = {"CDLCOUNTERATTACK", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_79CDLCOUNTERATTACK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_78CDLCOUNTERATTACK}; -static PyObject *__pyx_pw_5talib_7_ta_lib_79CDLCOUNTERATTACK(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -19936,7 +14134,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLCOUNTERATTACK (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -19944,72 +14142,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1184, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1184, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1184, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1184, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1114, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1114, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, 1); __PYX_ERR(3, 1114, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1114, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, 2); __PYX_ERR(3, 1114, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1114, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, 3); __PYX_ERR(3, 1114, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLCOUNTERATTACK") < 0)) __PYX_ERR(3, 1114, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1184, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1184, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1184, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1184, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -20018,42 +14190,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1114, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1184, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1116, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1116, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1116, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1116, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1186, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1186, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1186, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1186, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_82CDLCOUNTERATTACK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -20066,12 +14237,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObj __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -20081,53 +14247,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1133, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1134, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1135, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1136, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1137, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1138, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1138, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1138, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1138, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1138, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCOUNTERATTACK_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1141, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1142, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1142, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1142, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1142, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1142, __pyx_L1_error) - __pyx_v_retCode = TA_CDLCOUNTERATTACK(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLCOUNTERATTACK(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCOUNTERATTACK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1143, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCOUNTERATTACK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -20155,16 +14312,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_81CDLDARKCLOUDCOVER(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_85CDLDARKCLOUDCOVER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_80CDLDARKCLOUDCOVER, " CDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\n Dark Cloud Cover (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.5\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_81CDLDARKCLOUDCOVER = {"CDLDARKCLOUDCOVER", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_81CDLDARKCLOUDCOVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_80CDLDARKCLOUDCOVER}; -static PyObject *__pyx_pw_5talib_7_ta_lib_81CDLDARKCLOUDCOVER(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -20188,7 +14345,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLDARKCLOUDCOVER (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -20196,82 +14353,54 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1216, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1216, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1216, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1216, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1216, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1146, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1146, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, 1); __PYX_ERR(3, 1146, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1146, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, 2); __PYX_ERR(3, 1146, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1146, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, 3); __PYX_ERR(3, 1146, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1146, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLDARKCLOUDCOVER") < 0)) __PYX_ERR(3, 1146, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1216, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1216, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1216, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1216, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1216, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -20281,49 +14410,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 1148, __pyx_L3_error) + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 1218, __pyx_L3_error) } else { __pyx_v_penetration = ((double)((double)0.5)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, __pyx_nargs); __PYX_ERR(3, 1146, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 1216, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1148, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1148, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1148, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1148, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1218, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1218, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1218, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1218, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_84CDLDARKCLOUDCOVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -20336,12 +14464,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyOb __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -20351,53 +14474,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyOb __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1167, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1168, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1169, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1170, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1240, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1171, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1172, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1172, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1172, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1172, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1172, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDARKCLOUDCOVER_Lookback(__pyx_v_penetration)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1175, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1176, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1176, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1176, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1176, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1176, __pyx_L1_error) - __pyx_v_retCode = TA_CDLDARKCLOUDCOVER(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLDARKCLOUDCOVER(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDARKCLOUDCOVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1177, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDARKCLOUDCOVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -20425,16 +14539,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_83CDLDOJI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_87CDLDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_82CDLDOJI, " CDLDOJI(open, high, low, close)\n\n Doji (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_83CDLDOJI = {"CDLDOJI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_83CDLDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_82CDLDOJI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_83CDLDOJI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -20457,7 +14571,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLDOJI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -20465,72 +14579,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1250, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1250, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1250, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1250, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1180, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1180, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, 1); __PYX_ERR(3, 1180, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1180, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, 2); __PYX_ERR(3, 1180, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1180, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, 3); __PYX_ERR(3, 1180, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLDOJI") < 0)) __PYX_ERR(3, 1180, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1250, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1250, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1250, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1250, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -20539,42 +14627,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1180, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1250, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1182, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1182, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1182, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1182, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_82CDLDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1252, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1252, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1252, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1252, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_86CDLDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -20587,12 +14674,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -20602,53 +14684,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__py __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1199, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1200, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1201, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1202, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1203, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1204, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1204, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1204, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1204, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1204, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDOJI_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1207, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1208, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1208, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1208, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1208, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1208, __pyx_L1_error) - __pyx_v_retCode = TA_CDLDOJI(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLDOJI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1209, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -20676,16 +14749,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_85CDLDOJISTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_89CDLDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_84CDLDOJISTAR, " CDLDOJISTAR(open, high, low, close)\n\n Doji Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_85CDLDOJISTAR = {"CDLDOJISTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_85CDLDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_84CDLDOJISTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_85CDLDOJISTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -20708,7 +14781,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLDOJISTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -20716,72 +14789,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1282, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1282, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1282, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1282, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1212, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1212, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, 1); __PYX_ERR(3, 1212, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1212, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, 2); __PYX_ERR(3, 1212, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1212, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, 3); __PYX_ERR(3, 1212, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLDOJISTAR") < 0)) __PYX_ERR(3, 1212, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1282, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1282, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1282, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1282, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -20790,42 +14837,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1212, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1282, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1214, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1214, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1214, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1214, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1284, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1284, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1284, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1284, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_88CDLDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -20838,12 +14884,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject * __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -20853,53 +14894,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1231, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1232, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1233, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1234, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1235, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1236, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1236, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1236, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1236, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1236, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDOJISTAR_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1239, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1240, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1240, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1240, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1240, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1240, __pyx_L1_error) - __pyx_v_retCode = TA_CDLDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1241, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -20927,16 +14959,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_87CDLDRAGONFLYDOJI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_91CDLDRAGONFLYDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_86CDLDRAGONFLYDOJI, " CDLDRAGONFLYDOJI(open, high, low, close)\n\n Dragonfly Doji (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_87CDLDRAGONFLYDOJI = {"CDLDRAGONFLYDOJI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_87CDLDRAGONFLYDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_86CDLDRAGONFLYDOJI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_87CDLDRAGONFLYDOJI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -20959,7 +14991,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLDRAGONFLYDOJI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -20967,72 +14999,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1314, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1314, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1314, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1314, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1244, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1244, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, 1); __PYX_ERR(3, 1244, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1244, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, 2); __PYX_ERR(3, 1244, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1244, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, 3); __PYX_ERR(3, 1244, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLDRAGONFLYDOJI") < 0)) __PYX_ERR(3, 1244, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1314, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1314, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1314, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1314, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -21041,42 +15047,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1244, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1314, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1246, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1246, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1246, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1246, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1316, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1316, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1316, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1316, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_90CDLDRAGONFLYDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -21089,12 +15094,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObj __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -21104,53 +15104,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1263, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1264, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1265, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1266, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1267, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1268, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1268, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1268, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1268, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1268, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDRAGONFLYDOJI_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1271, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1272, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1272, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1272, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1272, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1272, __pyx_L1_error) - __pyx_v_retCode = TA_CDLDRAGONFLYDOJI(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLDRAGONFLYDOJI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDRAGONFLYDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1273, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDRAGONFLYDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -21178,16 +15169,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_89CDLENGULFING(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_93CDLENGULFING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_88CDLENGULFING, " CDLENGULFING(open, high, low, close)\n\n Engulfing Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_89CDLENGULFING = {"CDLENGULFING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_89CDLENGULFING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_88CDLENGULFING}; -static PyObject *__pyx_pw_5talib_7_ta_lib_89CDLENGULFING(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -21210,7 +15201,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLENGULFING (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -21218,72 +15209,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1346, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1346, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1346, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1346, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1276, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1276, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, 1); __PYX_ERR(3, 1276, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1276, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, 2); __PYX_ERR(3, 1276, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1276, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, 3); __PYX_ERR(3, 1276, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLENGULFING") < 0)) __PYX_ERR(3, 1276, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1346, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1346, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1346, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1346, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -21292,42 +15257,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1276, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1346, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1278, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1278, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1278, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1278, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_88CDLENGULFING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1348, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1348, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1348, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1348, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_92CDLENGULFING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -21340,12 +15304,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -21355,53 +15314,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1295, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1296, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1297, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1298, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1299, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1300, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1300, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1300, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1300, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1300, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLENGULFING_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1303, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1304, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1304, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1304, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1304, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1304, __pyx_L1_error) - __pyx_v_retCode = TA_CDLENGULFING(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLENGULFING(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLENGULFING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1305, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLENGULFING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -21429,16 +15379,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_91CDLEVENINGDOJISTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_95CDLEVENINGDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_90CDLEVENINGDOJISTAR, " CDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\n Evening Doji Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_91CDLEVENINGDOJISTAR = {"CDLEVENINGDOJISTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_91CDLEVENINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_90CDLEVENINGDOJISTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_91CDLEVENINGDOJISTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -21462,7 +15412,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLEVENINGDOJISTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -21470,82 +15420,54 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1378, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1378, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1378, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1378, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1378, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1308, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1308, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, 1); __PYX_ERR(3, 1308, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1308, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, 2); __PYX_ERR(3, 1308, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1308, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, 3); __PYX_ERR(3, 1308, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1308, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLEVENINGDOJISTAR") < 0)) __PYX_ERR(3, 1308, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1378, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1378, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1378, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1378, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1378, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -21555,49 +15477,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 1310, __pyx_L3_error) + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 1380, __pyx_L3_error) } else { __pyx_v_penetration = ((double)((double)0.3)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(3, 1308, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 1378, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1310, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1310, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1310, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1310, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1380, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1380, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1380, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1380, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_94CDLEVENINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -21610,12 +15531,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyO __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -21625,53 +15541,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyO __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1329, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1330, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1400, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1331, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1332, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1402, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1333, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1334, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1334, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1334, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1334, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1334, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLEVENINGDOJISTAR_Lookback(__pyx_v_penetration)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1337, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1338, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1338, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1338, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1338, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1338, __pyx_L1_error) - __pyx_v_retCode = TA_CDLEVENINGDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLEVENINGDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLEVENINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1339, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLEVENINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -21699,16 +15606,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_93CDLEVENINGSTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_97CDLEVENINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_92CDLEVENINGSTAR, " CDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\n Evening Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_93CDLEVENINGSTAR = {"CDLEVENINGSTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_93CDLEVENINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_92CDLEVENINGSTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_93CDLEVENINGSTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -21732,7 +15639,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLEVENINGSTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -21740,82 +15647,54 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1412, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1412, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1412, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1412, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1412, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1342, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1342, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, 1); __PYX_ERR(3, 1342, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1342, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, 2); __PYX_ERR(3, 1342, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1342, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, 3); __PYX_ERR(3, 1342, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1342, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLEVENINGSTAR") < 0)) __PYX_ERR(3, 1342, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1412, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1412, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1412, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1412, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1412, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -21825,49 +15704,258 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 1344, __pyx_L3_error) + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 1414, __pyx_L3_error) } else { __pyx_v_penetration = ((double)((double)0.3)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(3, 1342, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 1412, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1344, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1344, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1344, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1344, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1414, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1414, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1414, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1414, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_96CDLEVENINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { + npy_intp __pyx_v_length; + int __pyx_v_begidx; + int __pyx_v_endidx; + int __pyx_v_lookback; + TA_RetCode __pyx_v_retCode; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + PyArrayObject *__pyx_v_outinteger = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_intp __pyx_t_2; + npy_int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("CDLEVENINGSTAR", 0); + __Pyx_INCREF((PyObject *)__pyx_v_open); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __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)-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) + __pyx_v_begidx = __pyx_t_3; + + __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); + + __pyx_v_lookback = (__pyx_v_begidx + TA_CDLEVENINGSTAR_Lookback(__pyx_v_penetration)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + __pyx_v_retCode = TA_CDLEVENINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLEVENINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_outinteger); + __pyx_r = ((PyObject *)__pyx_v_outinteger); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_outinteger); + __Pyx_XDECREF((PyObject *)__pyx_v_open); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_open = 0; + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("CDLGAPSIDESIDEWHITE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + 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 (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1446, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1446, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1446, __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(4, 1446, __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, "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) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1446, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1446, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1446, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1446, __pyx_L3_error) } + __pyx_v_open = ((PyArrayObject *)values[0]); + __pyx_v_high = ((PyArrayObject *)values[1]); + __pyx_v_low = ((PyArrayObject *)values[2]); + __pyx_v_close = ((PyArrayObject *)values[3]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1446, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1448, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1448, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1448, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1448, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -21880,319 +15968,54 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(CYTHON_UNUSED PyObjec __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("CDLEVENINGSTAR", 0); + __Pyx_RefNannySetupContext("CDLGAPSIDESIDEWHITE", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1363, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1364, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1365, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1366, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1468, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 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(4, 1469, __pyx_L1_error) __pyx_v_length = __pyx_t_2; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1368, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1368, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1368, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1368, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1368, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; - - __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - - __pyx_v_lookback = (__pyx_v_begidx + TA_CDLEVENINGSTAR_Lookback(__pyx_v_penetration)); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1371, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; - - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1372, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1372, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1372, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1372, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1372, __pyx_L1_error) - __pyx_v_retCode = TA_CDLEVENINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); - - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLEVENINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1373, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_outinteger); - __pyx_r = ((PyObject *)__pyx_v_outinteger); - goto __pyx_L0; - - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_outinteger); - __Pyx_XDECREF((PyObject *)__pyx_v_open); - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); - __Pyx_XDECREF((PyObject *)__pyx_v_close); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - - -/* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE, " CDLGAPSIDESIDEWHITE(open, high, low, close)\n\n Up/Down-gap side-by-side white lines (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE = {"CDLGAPSIDESIDEWHITE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyArrayObject *__pyx_v_open = 0; - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; - PyArrayObject *__pyx_v_close = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("CDLGAPSIDESIDEWHITE (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1376, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1376, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, 1); __PYX_ERR(3, 1376, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1376, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, 2); __PYX_ERR(3, 1376, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1376, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, 3); __PYX_ERR(3, 1376, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLGAPSIDESIDEWHITE") < 0)) __PYX_ERR(3, 1376, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - } - __pyx_v_open = ((PyArrayObject *)values[0]); - __pyx_v_high = ((PyArrayObject *)values[1]); - __pyx_v_low = ((PyArrayObject *)values[2]); - __pyx_v_close = ((PyArrayObject *)values[3]); - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1376, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("talib._ta_lib.CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1378, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1378, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1378, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1378, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { - npy_intp __pyx_v_length; - int __pyx_v_begidx; - int __pyx_v_endidx; - int __pyx_v_lookback; - TA_RetCode __pyx_v_retCode; - int __pyx_v_outbegidx; - int __pyx_v_outnbelement; - PyArrayObject *__pyx_v_outinteger = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("CDLGAPSIDESIDEWHITE", 0); - __Pyx_INCREF((PyObject *)__pyx_v_open); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - __Pyx_INCREF((PyObject *)__pyx_v_close); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1395, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1396, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1397, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1398, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __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(3, 1399, __pyx_L1_error) - __pyx_v_length = __pyx_t_2; - - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1400, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1400, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1400, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1400, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1400, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLGAPSIDESIDEWHITE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1403, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1404, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1404, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1404, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1404, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1404, __pyx_L1_error) - __pyx_v_retCode = TA_CDLGAPSIDESIDEWHITE(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLGAPSIDESIDEWHITE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLGAPSIDESIDEWHITE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1405, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLGAPSIDESIDEWHITE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22220,16 +16043,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_97CDLGRAVESTONEDOJI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_101CDLGRAVESTONEDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_96CDLGRAVESTONEDOJI, " CDLGRAVESTONEDOJI(open, high, low, close)\n\n Gravestone Doji (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_97CDLGRAVESTONEDOJI = {"CDLGRAVESTONEDOJI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_97CDLGRAVESTONEDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_96CDLGRAVESTONEDOJI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_97CDLGRAVESTONEDOJI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -22252,7 +16075,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLGRAVESTONEDOJI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -22260,72 +16083,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1478, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1478, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1478, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1478, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1408, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1408, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, 1); __PYX_ERR(3, 1408, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1408, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, 2); __PYX_ERR(3, 1408, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1408, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, 3); __PYX_ERR(3, 1408, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLGRAVESTONEDOJI") < 0)) __PYX_ERR(3, 1408, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1478, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1478, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1478, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1478, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -22334,42 +16131,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1408, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1478, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1410, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1410, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1410, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1410, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1480, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1480, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1480, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1480, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_100CDLGRAVESTONEDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -22382,12 +16178,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyOb __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -22397,53 +16188,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyOb __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1427, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1428, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1429, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1430, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1431, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1432, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1432, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1432, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1432, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1432, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLGRAVESTONEDOJI_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1435, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1436, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1436, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1436, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1436, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1436, __pyx_L1_error) - __pyx_v_retCode = TA_CDLGRAVESTONEDOJI(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLGRAVESTONEDOJI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLGRAVESTONEDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1437, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLGRAVESTONEDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22471,16 +16253,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_99CDLHAMMER(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_103CDLHAMMER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_98CDLHAMMER, " CDLHAMMER(open, high, low, close)\n\n Hammer (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_99CDLHAMMER = {"CDLHAMMER", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_99CDLHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_98CDLHAMMER}; -static PyObject *__pyx_pw_5talib_7_ta_lib_99CDLHAMMER(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -22503,7 +16285,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLHAMMER (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -22511,72 +16293,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1510, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1510, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1510, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1510, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1440, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1440, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, 1); __PYX_ERR(3, 1440, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1440, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, 2); __PYX_ERR(3, 1440, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1440, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, 3); __PYX_ERR(3, 1440, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLHAMMER") < 0)) __PYX_ERR(3, 1440, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1510, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1510, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1510, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1510, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -22585,42 +16341,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1440, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1510, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1442, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1442, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1442, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1442, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_98CDLHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1512, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1512, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1512, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1512, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_102CDLHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -22633,12 +16388,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -22648,53 +16398,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1459, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1460, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1461, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1462, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1463, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1464, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1464, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1464, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1464, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1464, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHAMMER_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1467, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1468, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1468, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1468, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1468, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1468, __pyx_L1_error) - __pyx_v_retCode = TA_CDLHAMMER(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLHAMMER(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1469, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22722,16 +16463,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_101CDLHANGINGMAN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_105CDLHANGINGMAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_100CDLHANGINGMAN, " CDLHANGINGMAN(open, high, low, close)\n\n Hanging Man (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_101CDLHANGINGMAN = {"CDLHANGINGMAN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_101CDLHANGINGMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_100CDLHANGINGMAN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_101CDLHANGINGMAN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -22754,7 +16495,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLHANGINGMAN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -22762,72 +16503,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1542, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1542, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1542, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1542, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1472, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1472, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, 1); __PYX_ERR(3, 1472, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1472, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, 2); __PYX_ERR(3, 1472, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1472, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, 3); __PYX_ERR(3, 1472, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLHANGINGMAN") < 0)) __PYX_ERR(3, 1472, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1542, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1542, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1542, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1542, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -22836,42 +16551,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1472, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1542, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1474, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1474, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1474, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1474, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1544, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1544, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1544, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1544, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_104CDLHANGINGMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -22884,12 +16598,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObjec __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -22899,53 +16608,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObjec __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1491, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1561, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1492, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1562, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1493, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1494, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1564, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1495, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1496, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1496, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1496, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1496, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1496, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHANGINGMAN_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1499, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1500, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1500, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1500, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1500, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1500, __pyx_L1_error) - __pyx_v_retCode = TA_CDLHANGINGMAN(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLHANGINGMAN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHANGINGMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1501, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHANGINGMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22973,16 +16673,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_103CDLHARAMI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_107CDLHARAMI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_102CDLHARAMI, " CDLHARAMI(open, high, low, close)\n\n Harami Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_103CDLHARAMI = {"CDLHARAMI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_103CDLHARAMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_102CDLHARAMI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_103CDLHARAMI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -23005,7 +16705,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLHARAMI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -23013,72 +16713,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1574, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1574, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1574, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1574, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1504, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1504, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, 1); __PYX_ERR(3, 1504, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1504, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, 2); __PYX_ERR(3, 1504, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1504, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, 3); __PYX_ERR(3, 1504, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLHARAMI") < 0)) __PYX_ERR(3, 1504, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1574, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1574, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1574, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1574, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -23087,42 +16761,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1504, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1574, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1506, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1506, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1506, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1506, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_102CDLHARAMI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1576, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1576, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1576, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1576, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_106CDLHARAMI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -23135,12 +16808,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -23150,53 +16818,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *_ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1523, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1524, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1525, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1526, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1527, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1528, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1528, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1528, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1528, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1528, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHARAMI_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1531, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1532, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1532, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1532, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1532, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1532, __pyx_L1_error) - __pyx_v_retCode = TA_CDLHARAMI(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLHARAMI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHARAMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1533, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHARAMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1603, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -23224,16 +16883,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_105CDLHARAMICROSS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_109CDLHARAMICROSS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_104CDLHARAMICROSS, " CDLHARAMICROSS(open, high, low, close)\n\n Harami Cross Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_105CDLHARAMICROSS = {"CDLHARAMICROSS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_105CDLHARAMICROSS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_104CDLHARAMICROSS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_105CDLHARAMICROSS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -23256,7 +16915,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLHARAMICROSS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -23264,72 +16923,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1606, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1606, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1606, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1606, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1536, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1536, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, 1); __PYX_ERR(3, 1536, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1536, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, 2); __PYX_ERR(3, 1536, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1536, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, 3); __PYX_ERR(3, 1536, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLHARAMICROSS") < 0)) __PYX_ERR(3, 1536, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1606, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1606, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1606, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1606, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -23338,42 +16971,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1536, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1606, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1538, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1538, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1538, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1538, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1608, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1608, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1608, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1608, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_108CDLHARAMICROSS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -23386,12 +17018,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObje __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -23401,53 +17028,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObje __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1555, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1625, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1556, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1557, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1627, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1558, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1559, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1560, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1560, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1560, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1560, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1560, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHARAMICROSS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1563, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1564, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1564, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1564, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1564, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1564, __pyx_L1_error) - __pyx_v_retCode = TA_CDLHARAMICROSS(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLHARAMICROSS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHARAMICROSS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1565, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHARAMICROSS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1635, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -23475,16 +17093,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_107CDLHIGHWAVE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_111CDLHIGHWAVE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_106CDLHIGHWAVE, " CDLHIGHWAVE(open, high, low, close)\n\n High-Wave Candle (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_107CDLHIGHWAVE = {"CDLHIGHWAVE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_107CDLHIGHWAVE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_106CDLHIGHWAVE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_107CDLHIGHWAVE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -23507,7 +17125,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLHIGHWAVE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -23515,72 +17133,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1638, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1638, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1638, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1638, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1568, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1568, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, 1); __PYX_ERR(3, 1568, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1568, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, 2); __PYX_ERR(3, 1568, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1568, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, 3); __PYX_ERR(3, 1568, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLHIGHWAVE") < 0)) __PYX_ERR(3, 1568, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1638, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1638, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1638, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1638, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -23589,42 +17181,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1568, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1638, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1570, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1570, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1570, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1570, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1640, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1640, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1640, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1640, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_110CDLHIGHWAVE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -23637,12 +17228,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -23652,53 +17238,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1587, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1588, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1589, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1659, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1590, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1591, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1592, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1592, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1592, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1592, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1592, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHIGHWAVE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1595, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1665, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1596, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1596, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1596, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1596, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1596, __pyx_L1_error) - __pyx_v_retCode = TA_CDLHIGHWAVE(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLHIGHWAVE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIGHWAVE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1597, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIGHWAVE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -23726,16 +17303,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_109CDLHIKKAKE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_113CDLHIKKAKE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_108CDLHIKKAKE, " CDLHIKKAKE(open, high, low, close)\n\n Hikkake Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_109CDLHIKKAKE = {"CDLHIKKAKE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_109CDLHIKKAKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_108CDLHIKKAKE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_109CDLHIKKAKE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -23758,7 +17335,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLHIKKAKE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -23766,72 +17343,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1670, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1670, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1670, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1670, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1600, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1600, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, 1); __PYX_ERR(3, 1600, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1600, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, 2); __PYX_ERR(3, 1600, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1600, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, 3); __PYX_ERR(3, 1600, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLHIKKAKE") < 0)) __PYX_ERR(3, 1600, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1670, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1670, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1670, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1670, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -23840,42 +17391,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1600, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1670, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1602, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1602, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1602, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1602, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1672, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1672, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1672, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1672, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_112CDLHIKKAKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -23888,12 +17438,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject * __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -23903,53 +17448,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1619, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1689, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1620, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1690, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1621, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1622, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1623, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1624, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1624, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1624, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1624, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1624, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHIKKAKE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1627, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1628, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1628, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1628, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1628, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1628, __pyx_L1_error) - __pyx_v_retCode = TA_CDLHIKKAKE(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLHIKKAKE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIKKAKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1629, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIKKAKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -23977,16 +17513,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_111CDLHIKKAKEMOD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_115CDLHIKKAKEMOD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_110CDLHIKKAKEMOD, " CDLHIKKAKEMOD(open, high, low, close)\n\n Modified Hikkake Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_111CDLHIKKAKEMOD = {"CDLHIKKAKEMOD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_111CDLHIKKAKEMOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_110CDLHIKKAKEMOD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_111CDLHIKKAKEMOD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -24009,7 +17545,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLHIKKAKEMOD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -24017,72 +17553,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1702, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1702, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1702, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1702, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1632, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1632, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, 1); __PYX_ERR(3, 1632, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1632, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, 2); __PYX_ERR(3, 1632, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1632, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, 3); __PYX_ERR(3, 1632, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLHIKKAKEMOD") < 0)) __PYX_ERR(3, 1632, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1702, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1702, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1702, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1702, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -24091,42 +17601,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1632, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1702, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1634, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1634, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1634, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1634, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1704, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1704, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1704, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1704, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_114CDLHIKKAKEMOD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -24139,12 +17648,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObjec __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -24154,53 +17658,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObjec __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1651, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1652, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1722, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1653, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1723, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1654, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1724, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1655, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1656, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1656, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1656, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1656, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1656, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHIKKAKEMOD_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1659, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1660, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1660, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1660, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1660, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1660, __pyx_L1_error) - __pyx_v_retCode = TA_CDLHIKKAKEMOD(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLHIKKAKEMOD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIKKAKEMOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1661, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIKKAKEMOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1731, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -24228,16 +17723,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_113CDLHOMINGPIGEON(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_117CDLHOMINGPIGEON(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_112CDLHOMINGPIGEON, " CDLHOMINGPIGEON(open, high, low, close)\n\n Homing Pigeon (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_113CDLHOMINGPIGEON = {"CDLHOMINGPIGEON", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_113CDLHOMINGPIGEON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_112CDLHOMINGPIGEON}; -static PyObject *__pyx_pw_5talib_7_ta_lib_113CDLHOMINGPIGEON(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -24260,7 +17755,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLHOMINGPIGEON (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -24268,72 +17763,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1734, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1734, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1734, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1734, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1664, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1664, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, 1); __PYX_ERR(3, 1664, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1664, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, 2); __PYX_ERR(3, 1664, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1664, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, 3); __PYX_ERR(3, 1664, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLHOMINGPIGEON") < 0)) __PYX_ERR(3, 1664, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1734, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1734, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1734, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1734, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -24342,42 +17811,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1664, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1734, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1666, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1666, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1666, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1666, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1736, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1736, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1736, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1736, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_116CDLHOMINGPIGEON(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -24390,12 +17858,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObj __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -24405,53 +17868,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1683, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1684, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1685, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1686, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1687, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1688, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1688, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1688, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1688, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1688, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHOMINGPIGEON_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1691, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1692, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1692, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1692, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1692, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1692, __pyx_L1_error) - __pyx_v_retCode = TA_CDLHOMINGPIGEON(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLHOMINGPIGEON(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHOMINGPIGEON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1693, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHOMINGPIGEON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -24479,16 +17933,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_115CDLIDENTICAL3CROWS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_119CDLIDENTICAL3CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_114CDLIDENTICAL3CROWS, " CDLIDENTICAL3CROWS(open, high, low, close)\n\n Identical Three Crows (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_115CDLIDENTICAL3CROWS = {"CDLIDENTICAL3CROWS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_115CDLIDENTICAL3CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_114CDLIDENTICAL3CROWS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_115CDLIDENTICAL3CROWS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -24511,7 +17965,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLIDENTICAL3CROWS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -24519,72 +17973,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1766, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1766, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1766, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1766, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1696, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1696, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, 1); __PYX_ERR(3, 1696, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1696, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, 2); __PYX_ERR(3, 1696, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1696, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, 3); __PYX_ERR(3, 1696, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLIDENTICAL3CROWS") < 0)) __PYX_ERR(3, 1696, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1766, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1766, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1766, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1766, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -24593,42 +18021,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1696, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1766, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1698, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1698, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1698, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1698, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1768, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1768, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1768, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1768, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_118CDLIDENTICAL3CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -24641,12 +18068,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED Py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -24656,53 +18078,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED Py __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1715, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1716, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1717, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1718, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1719, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1720, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1720, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1720, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1720, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1720, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLIDENTICAL3CROWS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1723, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1724, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1724, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1724, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1724, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1724, __pyx_L1_error) - __pyx_v_retCode = TA_CDLIDENTICAL3CROWS(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLIDENTICAL3CROWS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLIDENTICAL3CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1725, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLIDENTICAL3CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -24730,16 +18143,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_117CDLINNECK(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_121CDLINNECK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_116CDLINNECK, " CDLINNECK(open, high, low, close)\n\n In-Neck Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_117CDLINNECK = {"CDLINNECK", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_117CDLINNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_116CDLINNECK}; -static PyObject *__pyx_pw_5talib_7_ta_lib_117CDLINNECK(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -24762,7 +18175,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLINNECK (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -24770,72 +18183,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1798, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1798, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1798, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1798, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1728, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1728, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, 1); __PYX_ERR(3, 1728, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1728, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, 2); __PYX_ERR(3, 1728, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1728, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, 3); __PYX_ERR(3, 1728, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLINNECK") < 0)) __PYX_ERR(3, 1728, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1798, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1798, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1798, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1798, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -24844,42 +18231,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1728, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1798, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1730, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1730, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1730, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1730, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_116CDLINNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1800, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1800, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1800, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1800, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_120CDLINNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -24892,12 +18278,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -24907,53 +18288,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *_ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1747, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1748, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1749, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1750, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1751, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1752, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1752, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1752, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1752, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1752, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLINNECK_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1755, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1756, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1756, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1756, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1756, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1756, __pyx_L1_error) - __pyx_v_retCode = TA_CDLINNECK(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLINNECK(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLINNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1757, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLINNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1827, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -24981,16 +18353,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_119CDLINVERTEDHAMMER(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_123CDLINVERTEDHAMMER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_118CDLINVERTEDHAMMER, " CDLINVERTEDHAMMER(open, high, low, close)\n\n Inverted Hammer (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_119CDLINVERTEDHAMMER = {"CDLINVERTEDHAMMER", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_119CDLINVERTEDHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_118CDLINVERTEDHAMMER}; -static PyObject *__pyx_pw_5talib_7_ta_lib_119CDLINVERTEDHAMMER(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -25013,7 +18385,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLINVERTEDHAMMER (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -25021,72 +18393,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1830, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1830, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1830, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1830, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1760, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1760, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, 1); __PYX_ERR(3, 1760, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1760, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, 2); __PYX_ERR(3, 1760, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1760, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, 3); __PYX_ERR(3, 1760, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLINVERTEDHAMMER") < 0)) __PYX_ERR(3, 1760, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1830, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1830, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1830, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1830, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -25095,42 +18441,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1760, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1830, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1762, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1762, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1762, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1762, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1832, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1832, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1832, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1832, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_122CDLINVERTEDHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -25143,12 +18488,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyO __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -25158,53 +18498,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyO __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1779, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1780, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1850, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1781, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1782, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1783, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1784, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1784, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1784, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1784, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1784, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLINVERTEDHAMMER_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1787, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1788, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1788, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1788, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1788, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1788, __pyx_L1_error) - __pyx_v_retCode = TA_CDLINVERTEDHAMMER(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLINVERTEDHAMMER(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLINVERTEDHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1789, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLINVERTEDHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1859, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -25232,16 +18563,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_121CDLKICKING(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_125CDLKICKING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_120CDLKICKING, " CDLKICKING(open, high, low, close)\n\n Kicking (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_121CDLKICKING = {"CDLKICKING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_121CDLKICKING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_120CDLKICKING}; -static PyObject *__pyx_pw_5talib_7_ta_lib_121CDLKICKING(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -25264,7 +18595,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLKICKING (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -25272,72 +18603,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1862, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1862, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1862, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1862, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1792, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1792, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, 1); __PYX_ERR(3, 1792, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1792, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, 2); __PYX_ERR(3, 1792, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1792, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, 3); __PYX_ERR(3, 1792, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLKICKING") < 0)) __PYX_ERR(3, 1792, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1862, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1862, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1862, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1862, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -25346,42 +18651,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1792, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1862, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1794, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1794, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1794, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1794, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_120CDLKICKING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1864, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1864, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1864, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1864, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_124CDLKICKING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -25394,12 +18698,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject * __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -25409,53 +18708,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1811, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1812, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1813, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1814, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1815, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1816, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1816, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1816, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1816, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1816, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLKICKING_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1819, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1820, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1820, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1820, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1820, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1820, __pyx_L1_error) - __pyx_v_retCode = TA_CDLKICKING(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLKICKING(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLKICKING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1821, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLKICKING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -25483,16 +18773,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_123CDLKICKINGBYLENGTH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_127CDLKICKINGBYLENGTH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_122CDLKICKINGBYLENGTH, " CDLKICKINGBYLENGTH(open, high, low, close)\n\n Kicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_123CDLKICKINGBYLENGTH = {"CDLKICKINGBYLENGTH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_123CDLKICKINGBYLENGTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_122CDLKICKINGBYLENGTH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_123CDLKICKINGBYLENGTH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -25515,7 +18805,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLKICKINGBYLENGTH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -25523,72 +18813,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1894, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1894, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1894, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1894, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1824, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1824, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, 1); __PYX_ERR(3, 1824, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1824, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, 2); __PYX_ERR(3, 1824, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1824, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, 3); __PYX_ERR(3, 1824, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLKICKINGBYLENGTH") < 0)) __PYX_ERR(3, 1824, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1894, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1894, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1894, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1894, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -25597,42 +18861,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1824, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1894, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1826, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1826, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1826, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1826, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1896, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1896, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1896, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1896, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_126CDLKICKINGBYLENGTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -25645,12 +18908,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED Py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -25660,53 +18918,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED Py __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1843, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1844, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1845, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1915, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1846, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1916, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1847, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1848, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1848, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1848, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1848, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1848, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLKICKINGBYLENGTH_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1851, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1852, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1852, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1852, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1852, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1852, __pyx_L1_error) - __pyx_v_retCode = TA_CDLKICKINGBYLENGTH(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLKICKINGBYLENGTH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLKICKINGBYLENGTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1853, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLKICKINGBYLENGTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1923, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -25734,16 +18983,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_125CDLLADDERBOTTOM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_129CDLLADDERBOTTOM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_124CDLLADDERBOTTOM, " CDLLADDERBOTTOM(open, high, low, close)\n\n Ladder Bottom (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_125CDLLADDERBOTTOM = {"CDLLADDERBOTTOM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_125CDLLADDERBOTTOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_124CDLLADDERBOTTOM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_125CDLLADDERBOTTOM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -25766,7 +19015,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLLADDERBOTTOM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -25774,72 +19023,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1926, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1926, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1926, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1926, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1856, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1856, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, 1); __PYX_ERR(3, 1856, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1856, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, 2); __PYX_ERR(3, 1856, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1856, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, 3); __PYX_ERR(3, 1856, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLLADDERBOTTOM") < 0)) __PYX_ERR(3, 1856, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1926, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1926, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1926, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1926, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -25848,42 +19071,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1856, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1926, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1858, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1858, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1858, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1858, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1928, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1928, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1928, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1928, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_128CDLLADDERBOTTOM(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -25896,12 +19118,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObj __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -25911,53 +19128,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1875, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1876, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1946, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1877, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1947, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1878, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1948, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1879, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1880, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1880, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1880, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1880, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1880, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLLADDERBOTTOM_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1883, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1953, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1884, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1884, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1884, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1884, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1884, __pyx_L1_error) - __pyx_v_retCode = TA_CDLLADDERBOTTOM(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLLADDERBOTTOM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLADDERBOTTOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1885, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLADDERBOTTOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1955, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -25985,16 +19193,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI, " CDLLONGLEGGEDDOJI(open, high, low, close)\n\n Long Legged Doji (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI = {"CDLLONGLEGGEDDOJI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -26017,7 +19225,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLLONGLEGGEDDOJI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -26025,72 +19233,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1958, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1958, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1958, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1958, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1888, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1888, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, 1); __PYX_ERR(3, 1888, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1888, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, 2); __PYX_ERR(3, 1888, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1888, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, 3); __PYX_ERR(3, 1888, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLLONGLEGGEDDOJI") < 0)) __PYX_ERR(3, 1888, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1958, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1958, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1958, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1958, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -26099,42 +19281,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1888, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1958, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1890, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1890, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1890, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1890, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1960, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1960, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1960, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1960, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -26147,12 +19328,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyO __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -26162,53 +19338,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyO __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1907, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1977, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1908, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1978, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1909, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1910, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1980, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1911, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1912, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1912, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1912, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1912, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1912, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLLONGLEGGEDDOJI_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1915, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1916, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1916, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1916, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1916, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1916, __pyx_L1_error) - __pyx_v_retCode = TA_CDLLONGLEGGEDDOJI(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLLONGLEGGEDDOJI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLONGLEGGEDDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1917, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLONGLEGGEDDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1987, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -26236,16 +19403,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_129CDLLONGLINE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_133CDLLONGLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_128CDLLONGLINE, " CDLLONGLINE(open, high, low, close)\n\n Long Line Candle (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_129CDLLONGLINE = {"CDLLONGLINE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_129CDLLONGLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_128CDLLONGLINE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_129CDLLONGLINE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -26268,7 +19435,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLLONGLINE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -26276,72 +19443,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1990, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1990, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1990, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1990, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1920, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1920, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, 1); __PYX_ERR(3, 1920, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1920, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, 2); __PYX_ERR(3, 1920, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1920, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, 3); __PYX_ERR(3, 1920, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLLONGLINE") < 0)) __PYX_ERR(3, 1920, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1990, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1990, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1990, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1990, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -26350,42 +19491,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1920, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1990, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1922, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1922, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1922, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1922, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1992, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1992, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1992, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1992, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_132CDLLONGLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -26398,12 +19538,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -26413,53 +19548,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1939, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1940, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2010, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1941, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2011, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1942, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1943, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1944, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1944, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1944, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1944, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1944, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLLONGLINE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1947, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2017, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1948, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1948, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1948, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1948, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1948, __pyx_L1_error) - __pyx_v_retCode = TA_CDLLONGLINE(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLLONGLINE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLONGLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1949, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLONGLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2019, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -26487,16 +19613,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_131CDLMARUBOZU(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_135CDLMARUBOZU(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_130CDLMARUBOZU, " CDLMARUBOZU(open, high, low, close)\n\n Marubozu (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_131CDLMARUBOZU = {"CDLMARUBOZU", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_131CDLMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_130CDLMARUBOZU}; -static PyObject *__pyx_pw_5talib_7_ta_lib_131CDLMARUBOZU(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -26519,7 +19645,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLMARUBOZU (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -26527,72 +19653,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2022, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2022, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2022, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2022, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1952, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1952, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, 1); __PYX_ERR(3, 1952, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1952, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, 2); __PYX_ERR(3, 1952, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1952, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, 3); __PYX_ERR(3, 1952, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLMARUBOZU") < 0)) __PYX_ERR(3, 1952, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2022, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2022, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2022, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2022, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -26601,42 +19701,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1952, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2022, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1954, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1954, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1954, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1954, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2024, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2024, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2024, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2024, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_134CDLMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -26649,12 +19748,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -26664,53 +19758,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1971, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2041, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1972, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2042, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1973, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2043, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1974, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 1975, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1976, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1976, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1976, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1976, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1976, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMARUBOZU_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1979, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2049, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1980, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1980, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1980, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1980, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 1980, __pyx_L1_error) - __pyx_v_retCode = TA_CDLMARUBOZU(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLMARUBOZU(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1981, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2051, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -26738,16 +19823,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_133CDLMATCHINGLOW(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_137CDLMATCHINGLOW(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_132CDLMATCHINGLOW, " CDLMATCHINGLOW(open, high, low, close)\n\n Matching Low (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_133CDLMATCHINGLOW = {"CDLMATCHINGLOW", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_133CDLMATCHINGLOW, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_132CDLMATCHINGLOW}; -static PyObject *__pyx_pw_5talib_7_ta_lib_133CDLMATCHINGLOW(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -26770,7 +19855,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLMATCHINGLOW (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -26778,72 +19863,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2054, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2054, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2054, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2054, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1984, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1984, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, 1); __PYX_ERR(3, 1984, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1984, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, 2); __PYX_ERR(3, 1984, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1984, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, 3); __PYX_ERR(3, 1984, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLMATCHINGLOW") < 0)) __PYX_ERR(3, 1984, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2054, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2054, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2054, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2054, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -26852,42 +19911,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 1984, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2054, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1986, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1986, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1986, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1986, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2056, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2056, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2056, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2056, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_136CDLMATCHINGLOW(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -26900,12 +19958,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObje __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -26915,53 +19968,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObje __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2003, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2073, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2004, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2074, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2005, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2006, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2076, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2007, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2008, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2008, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2008, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2008, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2008, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMATCHINGLOW_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2011, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2012, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2012, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2012, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2012, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2012, __pyx_L1_error) - __pyx_v_retCode = TA_CDLMATCHINGLOW(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLMATCHINGLOW(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMATCHINGLOW, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2013, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMATCHINGLOW, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2083, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -26989,16 +20033,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_135CDLMATHOLD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_139CDLMATHOLD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_134CDLMATHOLD, " CDLMATHOLD(open, high, low, close[, penetration=?])\n\n Mat Hold (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.5\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_135CDLMATHOLD = {"CDLMATHOLD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_135CDLMATHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_134CDLMATHOLD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_135CDLMATHOLD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -27022,7 +20066,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLMATHOLD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -27030,82 +20074,54 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2086, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2086, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2086, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2086, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2086, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2016, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2016, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, 1); __PYX_ERR(3, 2016, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2016, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, 2); __PYX_ERR(3, 2016, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2016, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, 3); __PYX_ERR(3, 2016, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2016, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLMATHOLD") < 0)) __PYX_ERR(3, 2016, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2086, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2086, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2086, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2086, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2086, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -27115,49 +20131,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 2018, __pyx_L3_error) + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 2088, __pyx_L3_error) } else { __pyx_v_penetration = ((double)((double)0.5)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, __pyx_nargs); __PYX_ERR(3, 2016, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 2086, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2018, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2018, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2018, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2018, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2088, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2088, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2088, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2088, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_138CDLMATHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -27170,12 +20185,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject * __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -27185,53 +20195,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2037, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2038, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2039, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2040, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2041, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2042, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2042, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2042, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2042, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2042, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMATHOLD_Lookback(__pyx_v_penetration)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2045, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2046, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2046, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2046, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2046, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2046, __pyx_L1_error) - __pyx_v_retCode = TA_CDLMATHOLD(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLMATHOLD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMATHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2047, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMATHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -27259,16 +20260,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_137CDLMORNINGDOJISTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_141CDLMORNINGDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_136CDLMORNINGDOJISTAR, " CDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\n Morning Doji Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_137CDLMORNINGDOJISTAR = {"CDLMORNINGDOJISTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_137CDLMORNINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_136CDLMORNINGDOJISTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_137CDLMORNINGDOJISTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -27292,7 +20293,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLMORNINGDOJISTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -27300,82 +20301,54 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2120, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2120, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2120, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2120, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2120, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2050, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2050, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, 1); __PYX_ERR(3, 2050, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2050, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, 2); __PYX_ERR(3, 2050, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2050, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, 3); __PYX_ERR(3, 2050, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2050, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLMORNINGDOJISTAR") < 0)) __PYX_ERR(3, 2050, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2120, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2120, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2120, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2120, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2120, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -27385,49 +20358,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 2052, __pyx_L3_error) + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 2122, __pyx_L3_error) } else { __pyx_v_penetration = ((double)((double)0.3)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(3, 2050, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 2120, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2052, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2052, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2052, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2052, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2122, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2122, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2122, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2122, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_140CDLMORNINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -27440,12 +20412,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED Py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -27455,53 +20422,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED Py __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2071, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2072, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2073, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2074, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2075, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2076, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2076, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2076, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2076, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2076, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMORNINGDOJISTAR_Lookback(__pyx_v_penetration)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2079, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2080, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2080, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2080, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2080, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2080, __pyx_L1_error) - __pyx_v_retCode = TA_CDLMORNINGDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLMORNINGDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMORNINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2081, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMORNINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -27529,16 +20487,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_139CDLMORNINGSTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_143CDLMORNINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_138CDLMORNINGSTAR, " CDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\n Morning Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_139CDLMORNINGSTAR = {"CDLMORNINGSTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_139CDLMORNINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_138CDLMORNINGSTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_139CDLMORNINGSTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -27562,7 +20520,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLMORNINGSTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -27570,82 +20528,54 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2154, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2154, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2154, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2154, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2154, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2084, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2084, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, 1); __PYX_ERR(3, 2084, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2084, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, 2); __PYX_ERR(3, 2084, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2084, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, 3); __PYX_ERR(3, 2084, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2084, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLMORNINGSTAR") < 0)) __PYX_ERR(3, 2084, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2154, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2154, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2154, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2154, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2154, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -27655,49 +20585,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 2086, __pyx_L3_error) + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 2156, __pyx_L3_error) } else { __pyx_v_penetration = ((double)((double)0.3)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(3, 2084, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 2154, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2086, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2086, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2086, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2086, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2156, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2156, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2156, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2156, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_142CDLMORNINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -27710,12 +20639,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObje __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -27725,53 +20649,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObje __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2105, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2106, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2107, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2177, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2108, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2178, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2109, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2110, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2110, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2110, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2110, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2110, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMORNINGSTAR_Lookback(__pyx_v_penetration)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2113, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2114, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2114, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2114, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2114, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2114, __pyx_L1_error) - __pyx_v_retCode = TA_CDLMORNINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLMORNINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMORNINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2115, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMORNINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2185, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -27799,16 +20714,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_141CDLONNECK(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_145CDLONNECK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_140CDLONNECK, " CDLONNECK(open, high, low, close)\n\n On-Neck Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_141CDLONNECK = {"CDLONNECK", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_141CDLONNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_140CDLONNECK}; -static PyObject *__pyx_pw_5talib_7_ta_lib_141CDLONNECK(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -27831,7 +20746,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLONNECK (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -27839,72 +20754,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2188, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2188, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2188, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2188, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2118, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2118, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, 1); __PYX_ERR(3, 2118, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2118, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, 2); __PYX_ERR(3, 2118, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2118, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, 3); __PYX_ERR(3, 2118, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLONNECK") < 0)) __PYX_ERR(3, 2118, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2188, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2188, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2188, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2188, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -27913,42 +20802,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2118, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2188, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2120, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2120, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2120, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2120, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_140CDLONNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2190, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2190, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2190, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2190, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_144CDLONNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -27961,12 +20849,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -27976,53 +20859,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *_ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2137, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2138, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2139, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2140, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2141, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2142, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2142, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2142, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2142, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2142, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLONNECK_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2145, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2146, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2146, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2146, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2146, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2146, __pyx_L1_error) - __pyx_v_retCode = TA_CDLONNECK(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLONNECK(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLONNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2147, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLONNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2217, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -28050,16 +20924,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_143CDLPIERCING(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_147CDLPIERCING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_142CDLPIERCING, " CDLPIERCING(open, high, low, close)\n\n Piercing Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_143CDLPIERCING = {"CDLPIERCING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_143CDLPIERCING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_142CDLPIERCING}; -static PyObject *__pyx_pw_5talib_7_ta_lib_143CDLPIERCING(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -28082,7 +20956,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLPIERCING (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -28090,72 +20964,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2220, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2220, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2220, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2220, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2150, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2150, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, 1); __PYX_ERR(3, 2150, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2150, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, 2); __PYX_ERR(3, 2150, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2150, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, 3); __PYX_ERR(3, 2150, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLPIERCING") < 0)) __PYX_ERR(3, 2150, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2220, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2220, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2220, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2220, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -28164,42 +21012,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2150, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2220, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2152, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2152, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2152, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2152, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_142CDLPIERCING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2222, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2222, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2222, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2222, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_146CDLPIERCING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -28212,12 +21059,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -28227,53 +21069,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2169, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2170, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2240, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2171, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2172, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2173, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2174, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2174, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2174, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2174, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2174, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLPIERCING_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2177, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2178, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2178, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2178, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2178, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2178, __pyx_L1_error) - __pyx_v_retCode = TA_CDLPIERCING(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLPIERCING(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLPIERCING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2179, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLPIERCING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -28301,16 +21134,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_145CDLRICKSHAWMAN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_149CDLRICKSHAWMAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_144CDLRICKSHAWMAN, " CDLRICKSHAWMAN(open, high, low, close)\n\n Rickshaw Man (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_145CDLRICKSHAWMAN = {"CDLRICKSHAWMAN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_145CDLRICKSHAWMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_144CDLRICKSHAWMAN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_145CDLRICKSHAWMAN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -28333,7 +21166,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLRICKSHAWMAN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -28341,72 +21174,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2252, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2252, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2252, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2252, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2182, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2182, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, 1); __PYX_ERR(3, 2182, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2182, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, 2); __PYX_ERR(3, 2182, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2182, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, 3); __PYX_ERR(3, 2182, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLRICKSHAWMAN") < 0)) __PYX_ERR(3, 2182, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2252, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2252, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2252, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2252, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -28415,42 +21222,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2182, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2252, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2184, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2184, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2184, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2184, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2254, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2254, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2254, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2254, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_148CDLRICKSHAWMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -28463,12 +21269,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObje __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -28478,53 +21279,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObje __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2201, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2202, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2203, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2204, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2205, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2206, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2206, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2206, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2206, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2206, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLRICKSHAWMAN_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2209, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2210, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2210, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2210, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2210, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2210, __pyx_L1_error) - __pyx_v_retCode = TA_CDLRICKSHAWMAN(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLRICKSHAWMAN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLRICKSHAWMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2211, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLRICKSHAWMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -28552,16 +21344,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_147CDLRISEFALL3METHODS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_151CDLRISEFALL3METHODS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_146CDLRISEFALL3METHODS, " CDLRISEFALL3METHODS(open, high, low, close)\n\n Rising/Falling Three Methods (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_147CDLRISEFALL3METHODS = {"CDLRISEFALL3METHODS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_147CDLRISEFALL3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_146CDLRISEFALL3METHODS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_147CDLRISEFALL3METHODS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -28584,7 +21376,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLRISEFALL3METHODS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -28592,72 +21384,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2284, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2284, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2284, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2284, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2214, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2214, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, 1); __PYX_ERR(3, 2214, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2214, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, 2); __PYX_ERR(3, 2214, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2214, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, 3); __PYX_ERR(3, 2214, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLRISEFALL3METHODS") < 0)) __PYX_ERR(3, 2214, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2284, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2284, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2284, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2284, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -28666,42 +21432,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2214, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2284, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2216, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2216, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2216, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2216, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2286, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2286, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2286, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2286, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_150CDLRISEFALL3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -28714,12 +21479,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED P __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -28729,53 +21489,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED P __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2233, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2234, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2235, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2236, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2237, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2238, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2238, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2238, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2238, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2238, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLRISEFALL3METHODS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2241, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2242, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2242, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2242, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2242, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2242, __pyx_L1_error) - __pyx_v_retCode = TA_CDLRISEFALL3METHODS(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLRISEFALL3METHODS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLRISEFALL3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2243, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLRISEFALL3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -28803,16 +21554,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_149CDLSEPARATINGLINES(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_153CDLSEPARATINGLINES(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_148CDLSEPARATINGLINES, " CDLSEPARATINGLINES(open, high, low, close)\n\n Separating Lines (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_149CDLSEPARATINGLINES = {"CDLSEPARATINGLINES", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_149CDLSEPARATINGLINES, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_148CDLSEPARATINGLINES}; -static PyObject *__pyx_pw_5talib_7_ta_lib_149CDLSEPARATINGLINES(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -28835,7 +21586,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLSEPARATINGLINES (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -28843,72 +21594,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2316, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2316, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2316, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2316, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2246, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2246, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, 1); __PYX_ERR(3, 2246, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2246, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, 2); __PYX_ERR(3, 2246, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2246, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, 3); __PYX_ERR(3, 2246, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLSEPARATINGLINES") < 0)) __PYX_ERR(3, 2246, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2316, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2316, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2316, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2316, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -28917,42 +21642,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2246, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2316, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2248, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2248, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2248, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2248, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2318, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2318, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2318, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2318, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_152CDLSEPARATINGLINES(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -28965,12 +21689,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED Py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -28980,53 +21699,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED Py __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2265, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2266, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2267, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2268, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2269, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2270, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2270, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2270, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2270, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2270, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSEPARATINGLINES_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2273, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2274, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2274, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2274, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2274, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2274, __pyx_L1_error) - __pyx_v_retCode = TA_CDLSEPARATINGLINES(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLSEPARATINGLINES(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSEPARATINGLINES, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2275, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSEPARATINGLINES, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -29054,16 +21764,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_151CDLSHOOTINGSTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_155CDLSHOOTINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_150CDLSHOOTINGSTAR, " CDLSHOOTINGSTAR(open, high, low, close)\n\n Shooting Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_151CDLSHOOTINGSTAR = {"CDLSHOOTINGSTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_151CDLSHOOTINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_150CDLSHOOTINGSTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_151CDLSHOOTINGSTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -29086,7 +21796,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLSHOOTINGSTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -29094,72 +21804,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2348, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2348, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2348, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2348, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2278, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2278, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, 1); __PYX_ERR(3, 2278, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2278, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, 2); __PYX_ERR(3, 2278, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2278, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, 3); __PYX_ERR(3, 2278, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLSHOOTINGSTAR") < 0)) __PYX_ERR(3, 2278, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2348, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2348, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2348, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2348, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -29168,42 +21852,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2278, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2348, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2280, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2280, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2280, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2280, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2350, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2350, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2350, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2350, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_154CDLSHOOTINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -29216,12 +21899,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObj __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -29231,53 +21909,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2297, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2298, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2299, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2300, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2301, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2302, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2302, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2302, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2302, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2302, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSHOOTINGSTAR_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2305, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2306, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2306, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2306, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2306, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2306, __pyx_L1_error) - __pyx_v_retCode = TA_CDLSHOOTINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLSHOOTINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSHOOTINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2307, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSHOOTINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -29305,16 +21974,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_153CDLSHORTLINE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_157CDLSHORTLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_152CDLSHORTLINE, " CDLSHORTLINE(open, high, low, close)\n\n Short Line Candle (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_153CDLSHORTLINE = {"CDLSHORTLINE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_153CDLSHORTLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_152CDLSHORTLINE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_153CDLSHORTLINE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -29337,7 +22006,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLSHORTLINE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -29345,72 +22014,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2380, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2380, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2380, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2380, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2310, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2310, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, 1); __PYX_ERR(3, 2310, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2310, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, 2); __PYX_ERR(3, 2310, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2310, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, 3); __PYX_ERR(3, 2310, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLSHORTLINE") < 0)) __PYX_ERR(3, 2310, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2380, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2380, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2380, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2380, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -29419,42 +22062,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2310, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2380, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2312, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2312, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2312, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2312, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2382, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2382, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2382, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2382, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_156CDLSHORTLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -29467,12 +22109,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -29482,53 +22119,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2329, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2330, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2400, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2331, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2332, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2402, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2333, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2334, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2334, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2334, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2334, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2334, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSHORTLINE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2337, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2338, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2338, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2338, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2338, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2338, __pyx_L1_error) - __pyx_v_retCode = TA_CDLSHORTLINE(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLSHORTLINE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSHORTLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2339, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSHORTLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -29556,16 +22184,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_155CDLSPINNINGTOP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_159CDLSPINNINGTOP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_154CDLSPINNINGTOP, " CDLSPINNINGTOP(open, high, low, close)\n\n Spinning Top (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_155CDLSPINNINGTOP = {"CDLSPINNINGTOP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_155CDLSPINNINGTOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_154CDLSPINNINGTOP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_155CDLSPINNINGTOP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -29588,7 +22216,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLSPINNINGTOP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -29596,72 +22224,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2412, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2412, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2412, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2412, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2342, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2342, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, 1); __PYX_ERR(3, 2342, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2342, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, 2); __PYX_ERR(3, 2342, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2342, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, 3); __PYX_ERR(3, 2342, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLSPINNINGTOP") < 0)) __PYX_ERR(3, 2342, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2412, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2412, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2412, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2412, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -29670,42 +22272,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2342, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2412, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2344, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2344, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2344, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2344, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2414, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2414, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2414, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2414, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_158CDLSPINNINGTOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -29718,12 +22319,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObje __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -29733,53 +22329,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObje __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2361, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2362, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2363, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2364, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2365, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2366, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2366, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2366, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2366, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2366, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSPINNINGTOP_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2369, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2370, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2370, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2370, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2370, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2370, __pyx_L1_error) - __pyx_v_retCode = TA_CDLSPINNINGTOP(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLSPINNINGTOP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSPINNINGTOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2371, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSPINNINGTOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -29807,16 +22394,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_157CDLSTALLEDPATTERN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_161CDLSTALLEDPATTERN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_156CDLSTALLEDPATTERN, " CDLSTALLEDPATTERN(open, high, low, close)\n\n Stalled Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_157CDLSTALLEDPATTERN = {"CDLSTALLEDPATTERN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_157CDLSTALLEDPATTERN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_156CDLSTALLEDPATTERN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_157CDLSTALLEDPATTERN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -29839,7 +22426,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLSTALLEDPATTERN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -29847,72 +22434,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2444, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2444, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2444, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2444, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2374, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2374, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, 1); __PYX_ERR(3, 2374, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2374, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, 2); __PYX_ERR(3, 2374, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2374, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, 3); __PYX_ERR(3, 2374, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLSTALLEDPATTERN") < 0)) __PYX_ERR(3, 2374, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2444, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2444, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2444, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2444, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -29921,42 +22482,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2374, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2444, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2376, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2376, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2376, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2376, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2446, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2446, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2446, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2446, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_160CDLSTALLEDPATTERN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -29969,12 +22529,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyO __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -29984,53 +22539,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyO __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2393, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2463, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2394, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2464, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2395, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2396, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2397, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2398, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2398, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2398, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2398, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2398, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSTALLEDPATTERN_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2401, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2402, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2402, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2402, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2402, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2402, __pyx_L1_error) - __pyx_v_retCode = TA_CDLSTALLEDPATTERN(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLSTALLEDPATTERN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSTALLEDPATTERN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2403, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSTALLEDPATTERN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -30058,16 +22604,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_159CDLSTICKSANDWICH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_163CDLSTICKSANDWICH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_158CDLSTICKSANDWICH, " CDLSTICKSANDWICH(open, high, low, close)\n\n Stick Sandwich (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_159CDLSTICKSANDWICH = {"CDLSTICKSANDWICH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_159CDLSTICKSANDWICH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_158CDLSTICKSANDWICH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_159CDLSTICKSANDWICH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -30090,7 +22636,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLSTICKSANDWICH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -30098,72 +22644,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2476, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2476, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2476, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2476, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2406, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2406, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, 1); __PYX_ERR(3, 2406, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2406, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, 2); __PYX_ERR(3, 2406, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2406, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, 3); __PYX_ERR(3, 2406, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLSTICKSANDWICH") < 0)) __PYX_ERR(3, 2406, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2476, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2476, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2476, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2476, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -30172,42 +22692,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2406, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2476, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2408, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2408, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2408, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2408, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2478, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2478, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2478, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2478, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_162CDLSTICKSANDWICH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -30220,12 +22739,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyOb __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -30235,53 +22749,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyOb __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2425, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2426, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2427, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2428, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2429, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2430, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2430, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2430, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2430, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2430, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSTICKSANDWICH_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2433, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2434, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2434, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2434, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2434, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2434, __pyx_L1_error) - __pyx_v_retCode = TA_CDLSTICKSANDWICH(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLSTICKSANDWICH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSTICKSANDWICH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2435, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSTICKSANDWICH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -30309,16 +22814,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_161CDLTAKURI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_165CDLTAKURI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_160CDLTAKURI, " CDLTAKURI(open, high, low, close)\n\n Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_161CDLTAKURI = {"CDLTAKURI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_161CDLTAKURI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_160CDLTAKURI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_161CDLTAKURI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -30341,7 +22846,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLTAKURI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -30349,72 +22854,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2508, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2508, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2508, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2508, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2438, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2438, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, 1); __PYX_ERR(3, 2438, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2438, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, 2); __PYX_ERR(3, 2438, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2438, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, 3); __PYX_ERR(3, 2438, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLTAKURI") < 0)) __PYX_ERR(3, 2438, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2508, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2508, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2508, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2508, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -30423,42 +22902,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2438, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2508, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2440, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2440, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2440, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2440, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_160CDLTAKURI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2510, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2510, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2510, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2510, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_164CDLTAKURI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -30471,12 +22949,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -30486,53 +22959,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *_ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2457, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2458, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2459, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2460, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2461, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2462, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2462, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2462, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2462, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2462, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTAKURI_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2465, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2466, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2466, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2466, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2466, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2466, __pyx_L1_error) - __pyx_v_retCode = TA_CDLTAKURI(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLTAKURI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTAKURI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2467, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTAKURI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -30560,16 +23024,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_163CDLTASUKIGAP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_167CDLTASUKIGAP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_162CDLTASUKIGAP, " CDLTASUKIGAP(open, high, low, close)\n\n Tasuki Gap (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_163CDLTASUKIGAP = {"CDLTASUKIGAP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_163CDLTASUKIGAP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_162CDLTASUKIGAP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_163CDLTASUKIGAP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -30592,7 +23056,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLTASUKIGAP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -30600,72 +23064,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2540, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2540, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2540, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2540, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2470, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2470, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, 1); __PYX_ERR(3, 2470, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2470, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, 2); __PYX_ERR(3, 2470, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2470, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, 3); __PYX_ERR(3, 2470, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLTASUKIGAP") < 0)) __PYX_ERR(3, 2470, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2540, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2540, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2540, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2540, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -30674,42 +23112,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2470, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2540, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2472, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2472, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2472, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2472, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2542, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2542, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2542, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2542, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_166CDLTASUKIGAP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -30722,12 +23159,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -30737,53 +23169,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2489, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2490, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2491, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2561, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2492, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2562, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2493, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2494, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2494, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2494, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2494, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2494, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTASUKIGAP_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2497, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2498, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2498, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2498, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2498, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2498, __pyx_L1_error) - __pyx_v_retCode = TA_CDLTASUKIGAP(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLTASUKIGAP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTASUKIGAP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2499, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTASUKIGAP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -30811,16 +23234,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_165CDLTHRUSTING(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_169CDLTHRUSTING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_164CDLTHRUSTING, " CDLTHRUSTING(open, high, low, close)\n\n Thrusting Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_165CDLTHRUSTING = {"CDLTHRUSTING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_165CDLTHRUSTING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_164CDLTHRUSTING}; -static PyObject *__pyx_pw_5talib_7_ta_lib_165CDLTHRUSTING(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -30843,7 +23266,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLTHRUSTING (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -30851,72 +23274,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2572, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2572, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2572, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2572, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2502, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2502, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, 1); __PYX_ERR(3, 2502, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2502, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, 2); __PYX_ERR(3, 2502, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2502, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, 3); __PYX_ERR(3, 2502, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLTHRUSTING") < 0)) __PYX_ERR(3, 2502, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2572, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2572, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2572, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2572, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -30925,42 +23322,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2502, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2572, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2504, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2504, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2504, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2504, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2574, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2574, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2574, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2574, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_168CDLTHRUSTING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -30973,12 +23369,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -30988,53 +23379,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2521, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2522, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2523, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2524, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2525, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2526, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2526, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2526, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2526, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2526, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTHRUSTING_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2529, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2530, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2530, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2530, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2530, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2530, __pyx_L1_error) - __pyx_v_retCode = TA_CDLTHRUSTING(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLTHRUSTING(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTHRUSTING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2531, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTHRUSTING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -31062,16 +23444,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_167CDLTRISTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_171CDLTRISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_166CDLTRISTAR, " CDLTRISTAR(open, high, low, close)\n\n Tristar Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_167CDLTRISTAR = {"CDLTRISTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_167CDLTRISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_166CDLTRISTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_167CDLTRISTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -31094,7 +23476,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLTRISTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -31102,72 +23484,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2604, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2604, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2604, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2604, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2534, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2534, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, 1); __PYX_ERR(3, 2534, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2534, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, 2); __PYX_ERR(3, 2534, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2534, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, 3); __PYX_ERR(3, 2534, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLTRISTAR") < 0)) __PYX_ERR(3, 2534, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2604, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2604, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2604, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2604, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -31176,42 +23532,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2534, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2604, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2536, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2536, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2536, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2536, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2606, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2606, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2606, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2606, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_170CDLTRISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -31224,12 +23579,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject * __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -31239,53 +23589,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2553, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2623, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2554, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2624, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2555, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2625, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2556, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2557, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2558, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2558, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2558, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2558, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2558, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTRISTAR_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2561, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2562, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2562, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2562, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2562, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2562, __pyx_L1_error) - __pyx_v_retCode = TA_CDLTRISTAR(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLTRISTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTRISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2563, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTRISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -31313,16 +23654,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_169CDLUNIQUE3RIVER(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_173CDLUNIQUE3RIVER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_168CDLUNIQUE3RIVER, " CDLUNIQUE3RIVER(open, high, low, close)\n\n Unique 3 River (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_169CDLUNIQUE3RIVER = {"CDLUNIQUE3RIVER", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_169CDLUNIQUE3RIVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_168CDLUNIQUE3RIVER}; -static PyObject *__pyx_pw_5talib_7_ta_lib_169CDLUNIQUE3RIVER(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -31345,7 +23686,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLUNIQUE3RIVER (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -31353,72 +23694,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2636, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2636, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2636, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2636, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2566, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2566, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, 1); __PYX_ERR(3, 2566, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2566, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, 2); __PYX_ERR(3, 2566, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2566, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, 3); __PYX_ERR(3, 2566, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLUNIQUE3RIVER") < 0)) __PYX_ERR(3, 2566, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2636, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2636, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2636, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2636, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -31427,42 +23742,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2566, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2636, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2568, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2568, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2568, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2568, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2638, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2638, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2638, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2638, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_172CDLUNIQUE3RIVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -31475,12 +23789,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObj __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -31490,53 +23799,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2585, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2655, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2586, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2587, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2588, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2589, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2590, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2590, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2590, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2590, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2590, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLUNIQUE3RIVER_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2593, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2594, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2594, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2594, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2594, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2594, __pyx_L1_error) - __pyx_v_retCode = TA_CDLUNIQUE3RIVER(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLUNIQUE3RIVER(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLUNIQUE3RIVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2595, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLUNIQUE3RIVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2665, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -31564,16 +23864,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_171CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS, " CDLUPSIDEGAP2CROWS(open, high, low, close)\n\n Upside Gap Two Crows (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_171CDLUPSIDEGAP2CROWS = {"CDLUPSIDEGAP2CROWS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_171CDLUPSIDEGAP2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_171CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -31596,7 +23896,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLUPSIDEGAP2CROWS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -31604,72 +23904,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2668, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2668, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2668, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2668, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2598, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2598, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, 1); __PYX_ERR(3, 2598, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2598, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, 2); __PYX_ERR(3, 2598, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2598, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, 3); __PYX_ERR(3, 2598, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLUPSIDEGAP2CROWS") < 0)) __PYX_ERR(3, 2598, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2668, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2668, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2668, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2668, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -31678,42 +23952,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2598, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2668, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2600, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2600, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2600, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2600, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2670, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2670, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2670, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2670, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -31726,12 +23999,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED Py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -31741,53 +24009,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED Py __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2617, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2618, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2688, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2619, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2689, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2620, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2690, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2621, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2622, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2622, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2622, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2622, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2622, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLUPSIDEGAP2CROWS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2625, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2626, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2626, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2626, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2626, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2626, __pyx_L1_error) - __pyx_v_retCode = TA_CDLUPSIDEGAP2CROWS(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLUPSIDEGAP2CROWS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLUPSIDEGAP2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2627, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLUPSIDEGAP2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -31815,16 +24074,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_173CDLXSIDEGAP3METHODS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS, " CDLXSIDEGAP3METHODS(open, high, low, close)\n\n Upside/Downside Gap Three Methods (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_173CDLXSIDEGAP3METHODS = {"CDLXSIDEGAP3METHODS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_173CDLXSIDEGAP3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_173CDLXSIDEGAP3METHODS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -31847,7 +24106,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLXSIDEGAP3METHODS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -31855,72 +24114,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2700, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2700, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2700, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2700, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2630, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2630, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, 1); __PYX_ERR(3, 2630, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2630, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, 2); __PYX_ERR(3, 2630, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2630, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, 3); __PYX_ERR(3, 2630, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CDLXSIDEGAP3METHODS") < 0)) __PYX_ERR(3, 2630, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2700, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2700, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2700, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2700, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -31929,42 +24162,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(3, 2630, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2700, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2632, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2632, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2632, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2632, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2702, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2702, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2702, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2702, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -31977,12 +24209,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED P __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -31992,53 +24219,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED P __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2649, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2650, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2720, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2651, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2652, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2722, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2653, __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_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2654, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2654, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2654, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2654, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2654, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CDLXSIDEGAP3METHODS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2657, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2658, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2658, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2658, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2658, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2658, __pyx_L1_error) - __pyx_v_retCode = TA_CDLXSIDEGAP3METHODS(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CDLXSIDEGAP3METHODS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLXSIDEGAP3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2659, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLXSIDEGAP3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -32066,16 +24284,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_175CEIL(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_179CEIL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_174CEIL, " CEIL(real)\n\n Vector Ceil (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_175CEIL = {"CEIL", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_175CEIL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_174CEIL}; -static PyObject *__pyx_pw_5talib_7_ta_lib_175CEIL(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -32095,7 +24313,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CEIL (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -32103,71 +24321,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2732, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2662, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CEIL") < 0)) __PYX_ERR(3, 2662, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2732, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CEIL", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 2662, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CEIL", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 2732, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2664, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_174CEIL(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2734, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_178CEIL(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_174CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_178CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -32179,42 +24391,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_174CEIL(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("CEIL", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2681, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2751, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2682, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2683, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2683, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2753, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CEIL_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2686, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2687, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2687, __pyx_L1_error) - __pyx_v_retCode = TA_CEIL(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CEIL(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CEIL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2688, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CEIL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -32239,16 +24444,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_174CEIL(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_177CMO(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_181CMO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_176CMO, " CMO(real[, timeperiod=?])\n\n Chande Momentum Oscillator (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_177CMO = {"CMO", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_177CMO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_176CMO}; -static PyObject *__pyx_pw_5talib_7_ta_lib_177CMO(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -32269,7 +24474,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CMO (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -32277,89 +24482,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2761, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2761, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2691, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2691, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CMO") < 0)) __PYX_ERR(3, 2691, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2761, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2761, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2693, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2763, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CMO", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 2691, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CMO", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 2761, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CMO", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2693, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_176CMO(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2763, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_180CMO(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_176CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_180CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -32371,42 +24568,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_176CMO(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("CMO", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2712, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2713, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2714, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2714, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2784, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CMO_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2717, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2718, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2718, __pyx_L1_error) - __pyx_v_retCode = TA_CMO(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CMO(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CMO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2719, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CMO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -32431,16 +24621,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_176CMO(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_179CORREL(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_183CORREL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_178CORREL, " CORREL(real0, real1[, timeperiod=?])\n\n Pearson's Correlation Coefficient (r) (Statistic Functions)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_179CORREL = {"CORREL", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_179CORREL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_178CORREL}; -static PyObject *__pyx_pw_5talib_7_ta_lib_179CORREL(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -32462,7 +24652,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CORREL (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -32470,56 +24660,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2792, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2792, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2792, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2722, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2722, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("CORREL", 0, 2, 3, 1); __PYX_ERR(3, 2722, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2722, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "CORREL") < 0)) __PYX_ERR(3, 2722, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2792, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2792, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2792, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -32527,47 +24703,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2724, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2794, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("CORREL", 0, 2, 3, __pyx_nargs); __PYX_ERR(3, 2722, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("CORREL", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 2792, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 2724, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 2724, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_178CORREL(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 2794, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 2794, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_182CORREL(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_178CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_182CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -32580,10 +24755,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_178CORREL(CYTHON_UNUSED PyObject *__py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -32591,39 +24763,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_178CORREL(CYTHON_UNUSED PyObject *__py __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2744, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2745, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2746, __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_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2747, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2747, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2747, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_CORREL_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2750, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2751, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2751, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2751, __pyx_L1_error) - __pyx_v_retCode = TA_CORREL(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_CORREL(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CORREL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2752, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CORREL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -32649,16 +24816,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_178CORREL(CYTHON_UNUSED PyObject *__py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_181COS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_185COS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_180COS, " COS(real)\n\n Vector Trigonometric Cos (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_181COS = {"COS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_181COS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_180COS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_181COS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -32678,7 +24845,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("COS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -32686,71 +24853,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2825, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2755, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "COS") < 0)) __PYX_ERR(3, 2755, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2825, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("COS", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 2755, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("COS", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 2825, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.COS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2757, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_180COS(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2827, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_184COS(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_180COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_184COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -32762,42 +24923,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_180COS(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("COS", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2774, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2844, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2775, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2776, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2776, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2846, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_COS_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2779, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2780, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2780, __pyx_L1_error) - __pyx_v_retCode = TA_COS(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_COS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_COS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2781, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_COS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -32822,16 +24976,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_180COS(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_183COSH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_187COSH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_182COSH, " COSH(real)\n\n Vector Trigonometric Cosh (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_183COSH = {"COSH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_183COSH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_182COSH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_183COSH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -32851,7 +25005,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("COSH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -32859,71 +25013,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2854, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2784, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "COSH") < 0)) __PYX_ERR(3, 2784, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2854, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("COSH", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 2784, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("COSH", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 2854, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.COSH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2786, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_182COSH(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2856, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_186COSH(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_182COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_186COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -32935,42 +25083,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_182COSH(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("COSH", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2803, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2804, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2805, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2805, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2875, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_COSH_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2808, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2809, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2809, __pyx_L1_error) - __pyx_v_retCode = TA_COSH(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_COSH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_COSH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2810, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_COSH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -32995,16 +25136,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_182COSH(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_185DEMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_189DEMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_184DEMA, " DEMA(real[, timeperiod=?])\n\n Double Exponential Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_185DEMA = {"DEMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_185DEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_184DEMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_185DEMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -33025,7 +25166,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("DEMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -33033,89 +25174,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2883, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2883, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2813, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2813, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "DEMA") < 0)) __PYX_ERR(3, 2813, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2883, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2883, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2815, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2885, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("DEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 2813, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("DEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 2883, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2815, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_184DEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2885, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_188DEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_184DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_188DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -33127,42 +25260,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_184DEMA(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("DEMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2834, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2904, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2835, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2836, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2836, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2906, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_DEMA_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2839, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2909, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2840, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2840, __pyx_L1_error) - __pyx_v_retCode = TA_DEMA(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_DEMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2841, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2911, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -33187,16 +25313,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_184DEMA(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_187DIV(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_191DIV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_186DIV, " DIV(real0, real1)\n\n Vector Arithmetic Div (Math Operators)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_187DIV = {"DIV", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_187DIV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_186DIV}; -static PyObject *__pyx_pw_5talib_7_ta_lib_187DIV(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -33217,7 +25343,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("DIV (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -33225,86 +25351,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2914, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2914, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2844, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2844, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("DIV", 1, 2, 2, 1); __PYX_ERR(3, 2844, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "DIV") < 0)) __PYX_ERR(3, 2844, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2914, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2914, __pyx_L3_error) } __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("DIV", 1, 2, 2, __pyx_nargs); __PYX_ERR(3, 2844, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("DIV", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 2914, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.DIV", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 2846, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 2846, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_186DIV(__pyx_self, __pyx_v_real0, __pyx_v_real1); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 2916, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 2916, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_190DIV(__pyx_self, __pyx_v_real0, __pyx_v_real1); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_186DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { +static PyObject *__pyx_pf_5talib_7_ta_lib_190DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -33317,10 +25430,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_186DIV(CYTHON_UNUSED PyObject *__pyx_s __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -33328,39 +25438,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_186DIV(CYTHON_UNUSED PyObject *__pyx_s __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2864, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2934, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2865, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2935, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2866, __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_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2867, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2867, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2867, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_DIV_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2870, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2871, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2871, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2871, __pyx_L1_error) - __pyx_v_retCode = TA_DIV(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_DIV(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DIV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2872, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DIV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2942, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -33386,16 +25491,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_186DIV(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_189DX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_193DX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_188DX, " DX(high, low, close[, timeperiod=?])\n\n Directional Movement Index (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_189DX = {"DX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_189DX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_188DX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_189DX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -33418,7 +25523,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("DX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -33426,69 +25531,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2945, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2945, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2945, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2945, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2875, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2875, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, 1); __PYX_ERR(3, 2875, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2875, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, 2); __PYX_ERR(3, 2875, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2875, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "DX") < 0)) __PYX_ERR(3, 2875, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2945, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2945, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2945, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2945, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -33497,48 +25581,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2877, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2947, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, __pyx_nargs); __PYX_ERR(3, 2875, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 2945, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.DX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2877, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2877, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2877, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_188DX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2947, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2947, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2947, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_192DX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_188DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_192DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -33551,11 +25634,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_188DX(CYTHON_UNUSED PyObject *__pyx_se __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -33564,46 +25643,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_188DX(CYTHON_UNUSED PyObject *__pyx_se __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2896, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2966, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2897, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2967, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2898, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2968, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 2899, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2900, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2900, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2900, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2900, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_DX_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2903, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2904, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2904, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2904, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2904, __pyx_L1_error) - __pyx_v_retCode = TA_DX(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_DX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2905, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2975, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -33630,16 +25702,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_188DX(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_191EMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_195EMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_190EMA, " EMA(real[, timeperiod=?])\n\n Exponential Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_191EMA = {"EMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_191EMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_190EMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_191EMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -33660,7 +25732,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("EMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -33668,89 +25740,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2978, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2978, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2908, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2908, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "EMA") < 0)) __PYX_ERR(3, 2908, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2978, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2978, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2910, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2980, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("EMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 2908, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("EMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 2978, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.EMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2910, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_190EMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2980, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_194EMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_190EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_194EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -33762,42 +25826,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_190EMA(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("EMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2929, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2999, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2930, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2931, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2931, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3001, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_EMA_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2934, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3004, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2935, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2935, __pyx_L1_error) - __pyx_v_retCode = TA_EMA(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_EMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_EMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2936, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_EMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -33822,16 +25879,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_190EMA(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_193EXP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_197EXP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_192EXP, " EXP(real)\n\n Vector Arithmetic Exp (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_193EXP = {"EXP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_193EXP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_192EXP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_193EXP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -33851,7 +25908,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("EXP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -33859,71 +25916,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3009, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2939, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "EXP") < 0)) __PYX_ERR(3, 2939, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3009, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("EXP", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 2939, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("EXP", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3009, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.EXP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2941, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_192EXP(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3011, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_196EXP(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_192EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_196EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -33935,42 +25986,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_192EXP(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("EXP", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2958, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3028, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2959, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2960, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2960, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3030, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_EXP_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2963, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3033, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2964, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2964, __pyx_L1_error) - __pyx_v_retCode = TA_EXP(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_EXP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_EXP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2965, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_EXP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3035, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -33995,16 +26039,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_192EXP(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_195FLOOR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_199FLOOR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_194FLOOR, " FLOOR(real)\n\n Vector Floor (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_195FLOOR = {"FLOOR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_195FLOOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_194FLOOR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_195FLOOR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -34024,7 +26068,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("FLOOR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -34032,71 +26076,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3038, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2968, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "FLOOR") < 0)) __PYX_ERR(3, 2968, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3038, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("FLOOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 2968, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("FLOOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3038, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2970, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_194FLOOR(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3040, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_198FLOOR(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_194FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_198FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -34108,42 +26146,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_194FLOOR(CYTHON_UNUSED PyObject *__pyx PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("FLOOR", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2987, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3057, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2988, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2989, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2989, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3059, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_FLOOR_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2992, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3062, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2993, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 2993, __pyx_L1_error) - __pyx_v_retCode = TA_FLOOR(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_FLOOR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_FLOOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2994, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_FLOOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -34168,16 +26199,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_194FLOOR(CYTHON_UNUSED PyObject *__pyx /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_197HT_DCPERIOD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_201HT_DCPERIOD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_196HT_DCPERIOD, " HT_DCPERIOD(real)\n\n Hilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_197HT_DCPERIOD = {"HT_DCPERIOD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_197HT_DCPERIOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_196HT_DCPERIOD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_197HT_DCPERIOD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -34197,7 +26228,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("HT_DCPERIOD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -34205,71 +26236,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3067, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2997, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "HT_DCPERIOD") < 0)) __PYX_ERR(3, 2997, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3067, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("HT_DCPERIOD", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 2997, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("HT_DCPERIOD", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3067, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2999, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3069, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_200HT_DCPERIOD(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -34281,42 +26306,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("HT_DCPERIOD", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3016, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3017, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3018, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3018, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3088, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_HT_DCPERIOD_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3021, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3091, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3022, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3022, __pyx_L1_error) - __pyx_v_retCode = TA_HT_DCPERIOD(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_HT_DCPERIOD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_DCPERIOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3023, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_DCPERIOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3093, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -34341,16 +26359,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_199HT_DCPHASE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_203HT_DCPHASE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_198HT_DCPHASE, " HT_DCPHASE(real)\n\n Hilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_199HT_DCPHASE = {"HT_DCPHASE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_199HT_DCPHASE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_198HT_DCPHASE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_199HT_DCPHASE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -34370,7 +26388,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("HT_DCPHASE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -34378,71 +26396,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3096, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3026, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "HT_DCPHASE") < 0)) __PYX_ERR(3, 3026, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3096, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("HT_DCPHASE", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 3026, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("HT_DCPHASE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3096, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3028, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3098, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_202HT_DCPHASE(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -34454,42 +26466,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("HT_DCPHASE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3045, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3046, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3047, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3047, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3117, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_HT_DCPHASE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3050, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3051, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3051, __pyx_L1_error) - __pyx_v_retCode = TA_HT_DCPHASE(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_HT_DCPHASE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_DCPHASE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3052, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_DCPHASE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -34514,16 +26519,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_201HT_PHASOR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_205HT_PHASOR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_200HT_PHASOR, " HT_PHASOR(real)\n\n Hilbert Transform - Phasor Components (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n inphase\n quadrature\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_201HT_PHASOR = {"HT_PHASOR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_201HT_PHASOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_200HT_PHASOR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_201HT_PHASOR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -34543,7 +26548,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("HT_PHASOR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -34551,71 +26556,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3125, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3055, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "HT_PHASOR") < 0)) __PYX_ERR(3, 3055, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3125, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("HT_PHASOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 3055, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("HT_PHASOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3125, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3057, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_200HT_PHASOR(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3127, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_204HT_PHASOR(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -34628,61 +26627,52 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_PHASOR(CYTHON_UNUSED PyObject *_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("HT_PHASOR", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3076, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3146, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3077, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3078, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3078, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3148, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_HT_PHASOR_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3081, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinphase = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3082, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outquadrature = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3083, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinphase); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3083, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outquadrature); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3083, __pyx_L1_error) - __pyx_v_retCode = TA_HT_PHASOR(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_HT_PHASOR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinphase)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outquadrature)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_PHASOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3084, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_PHASOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3085, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outinphase); __Pyx_GIVEREF((PyObject *)__pyx_v_outinphase); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outinphase))) __PYX_ERR(3, 3085, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outinphase)) != (0)) __PYX_ERR(4, 3155, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outquadrature); __Pyx_GIVEREF((PyObject *)__pyx_v_outquadrature); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outquadrature))) __PYX_ERR(3, 3085, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outquadrature)) != (0)) __PYX_ERR(4, 3155, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -34704,16 +26694,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_PHASOR(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_203HT_SINE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_207HT_SINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_202HT_SINE, " HT_SINE(real)\n\n Hilbert Transform - SineWave (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n sine\n leadsine\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_203HT_SINE = {"HT_SINE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_203HT_SINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_202HT_SINE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_203HT_SINE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -34733,7 +26723,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("HT_SINE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -34741,71 +26731,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3157, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3087, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "HT_SINE") < 0)) __PYX_ERR(3, 3087, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3157, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("HT_SINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 3087, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("HT_SINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3157, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3089, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_202HT_SINE(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3159, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_206HT_SINE(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -34818,61 +26802,52 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_SINE(CYTHON_UNUSED PyObject *__p PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("HT_SINE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3108, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3178, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3109, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3110, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3110, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3180, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_HT_SINE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3113, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outsine = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3114, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outleadsine = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3115, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outsine); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3115, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outleadsine); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3115, __pyx_L1_error) - __pyx_v_retCode = TA_HT_SINE(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_HT_SINE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outsine)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outleadsine)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_SINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3116, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_SINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3117, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3187, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outsine); __Pyx_GIVEREF((PyObject *)__pyx_v_outsine); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outsine))) __PYX_ERR(3, 3117, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outsine)) != (0)) __PYX_ERR(4, 3187, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outleadsine); __Pyx_GIVEREF((PyObject *)__pyx_v_outleadsine); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outleadsine))) __PYX_ERR(3, 3117, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outleadsine)) != (0)) __PYX_ERR(4, 3187, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -34894,16 +26869,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_SINE(CYTHON_UNUSED PyObject *__p /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_205HT_TRENDLINE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_209HT_TRENDLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_204HT_TRENDLINE, " HT_TRENDLINE(real)\n\n Hilbert Transform - Instantaneous Trendline (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_205HT_TRENDLINE = {"HT_TRENDLINE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_205HT_TRENDLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_204HT_TRENDLINE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_205HT_TRENDLINE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -34923,7 +26898,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("HT_TRENDLINE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -34931,71 +26906,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3189, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3119, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "HT_TRENDLINE") < 0)) __PYX_ERR(3, 3119, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3189, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("HT_TRENDLINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 3119, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("HT_TRENDLINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3189, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3121, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3191, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_208HT_TRENDLINE(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_208HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -35007,42 +26976,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("HT_TRENDLINE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3138, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3139, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3140, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3140, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3210, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_HT_TRENDLINE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3143, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3144, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3144, __pyx_L1_error) - __pyx_v_retCode = TA_HT_TRENDLINE(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_HT_TRENDLINE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_TRENDLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3145, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_TRENDLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -35067,16 +27029,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_207HT_TRENDMODE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_211HT_TRENDMODE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_206HT_TRENDMODE, " HT_TRENDMODE(real)\n\n Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_207HT_TRENDMODE = {"HT_TRENDMODE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_207HT_TRENDMODE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_206HT_TRENDMODE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_207HT_TRENDMODE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -35096,7 +27058,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("HT_TRENDMODE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -35104,71 +27066,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3218, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3148, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "HT_TRENDMODE") < 0)) __PYX_ERR(3, 3148, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3218, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("HT_TRENDMODE", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 3148, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("HT_TRENDMODE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3218, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3150, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3220, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_210HT_TRENDMODE(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_210HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -35180,42 +27136,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("HT_TRENDMODE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3167, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3168, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3169, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3169, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3239, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_HT_TRENDMODE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3172, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3173, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3173, __pyx_L1_error) - __pyx_v_retCode = TA_HT_TRENDMODE(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_HT_TRENDMODE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_TRENDMODE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3174, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_TRENDMODE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -35240,37 +27189,38 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_209KAMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_213IMI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_208KAMA, " KAMA(real[, timeperiod=?])\n\n Kaufman Adaptive Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_209KAMA = {"KAMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_209KAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_208KAMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_209KAMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_real = 0; + PyArrayObject *__pyx_v_open = 0; + PyArrayObject *__pyx_v_close = 0; int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("KAMA (wrapper)", 0); + __Pyx_RefNannySetupContext("IMI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -35278,89 +27228,89 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3247, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3247, __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(4, 3247, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3177, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3177, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "KAMA") < 0)) __PYX_ERR(3, 3177, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3247, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3247, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3247, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } - __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3179, __pyx_L3_error) + __pyx_v_open = ((PyArrayObject *)values[0]); + __pyx_v_close = ((PyArrayObject *)values[1]); + if (values[2]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3249, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("KAMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3177, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("IMI", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 3247, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.IMI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3179, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_208KAMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 3249, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 3249, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_212IMI(__pyx_self, __pyx_v_open, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_212IMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -35372,42 +27322,43 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_intp __pyx_t_2; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("KAMA", 0); - __Pyx_INCREF((PyObject *)__pyx_v_real); + __Pyx_RefNannySetupContext("IMI", 0); + __Pyx_INCREF((PyObject *)__pyx_v_open); + __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3198, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3199, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[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)-1L))) __PYX_ERR(4, 3270, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3200, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3200, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - __pyx_v_lookback = (__pyx_v_begidx + TA_KAMA_Lookback(__pyx_v_timeperiod)); + __pyx_v_lookback = (__pyx_v_begidx + TA_IMI_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3203, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3204, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3204, __pyx_L1_error) - __pyx_v_retCode = TA_KAMA(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_IMI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_KAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3205, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_IMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -35420,11 +27371,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.IMI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); - __Pyx_XDECREF((PyObject *)__pyx_v_real); + __Pyx_XDECREF((PyObject *)__pyx_v_open); + __Pyx_XDECREF((PyObject *)__pyx_v_close); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -35432,16 +27384,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_211LINEARREG(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_215KAMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_210LINEARREG, " LINEARREG(real[, timeperiod=?])\n\n Linear Regression (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_211LINEARREG = {"LINEARREG", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_211LINEARREG, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_210LINEARREG}; -static PyObject *__pyx_pw_5talib_7_ta_lib_211LINEARREG(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -35460,9 +27412,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("LINEARREG (wrapper)", 0); + __Pyx_RefNannySetupContext("KAMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -35470,89 +27422,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3279, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3279, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3208, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3208, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "LINEARREG") < 0)) __PYX_ERR(3, 3208, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3279, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3279, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3210, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3281, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("LINEARREG", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3208, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("KAMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3279, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3210, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_210LINEARREG(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3281, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_214KAMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_214KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -35564,42 +27508,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("LINEARREG", 0); + __Pyx_RefNannySetupContext("KAMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3229, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3230, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3231, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3231, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3302, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_Lookback(__pyx_v_timeperiod)); + __pyx_v_lookback = (__pyx_v_begidx + TA_KAMA_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3234, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3235, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3235, __pyx_L1_error) - __pyx_v_retCode = TA_LINEARREG(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_KAMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3236, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_KAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -35612,7 +27549,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *_ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); @@ -35624,16 +27561,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_213LINEARREG_ANGLE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_217LINEARREG(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_212LINEARREG_ANGLE, " LINEARREG_ANGLE(real[, timeperiod=?])\n\n Linear Regression Angle (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_213LINEARREG_ANGLE = {"LINEARREG_ANGLE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_213LINEARREG_ANGLE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_212LINEARREG_ANGLE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_213LINEARREG_ANGLE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -35652,9 +27589,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("LINEARREG_ANGLE (wrapper)", 0); + __Pyx_RefNannySetupContext("LINEARREG (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -35662,89 +27599,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3310, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3310, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3239, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3239, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "LINEARREG_ANGLE") < 0)) __PYX_ERR(3, 3239, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3310, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3310, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3241, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3312, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("LINEARREG_ANGLE", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3239, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("LINEARREG", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3310, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3241, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3312, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_216LINEARREG(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -35756,42 +27685,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("LINEARREG_ANGLE", 0); + __Pyx_RefNannySetupContext("LINEARREG", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3260, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3261, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3262, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3262, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3333, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_ANGLE_Lookback(__pyx_v_timeperiod)); + __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3265, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3266, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3266, __pyx_L1_error) - __pyx_v_retCode = TA_LINEARREG_ANGLE(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_LINEARREG(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_ANGLE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3267, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -35804,7 +27726,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObj /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); @@ -35816,16 +27738,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_215LINEARREG_INTERCEPT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_219LINEARREG_ANGLE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_214LINEARREG_INTERCEPT, " LINEARREG_INTERCEPT(real[, timeperiod=?])\n\n Linear Regression Intercept (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_215LINEARREG_INTERCEPT = {"LINEARREG_INTERCEPT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_215LINEARREG_INTERCEPT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_214LINEARREG_INTERCEPT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_215LINEARREG_INTERCEPT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -35844,9 +27766,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("LINEARREG_INTERCEPT (wrapper)", 0); + __Pyx_RefNannySetupContext("LINEARREG_ANGLE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -35854,89 +27776,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3341, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3341, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3270, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3270, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "LINEARREG_INTERCEPT") < 0)) __PYX_ERR(3, 3270, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3341, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3341, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3272, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3343, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("LINEARREG_INTERCEPT", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3270, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("LINEARREG_ANGLE", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3341, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3272, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3343, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_218LINEARREG_ANGLE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_218LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -35948,42 +27862,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED P PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("LINEARREG_INTERCEPT", 0); + __Pyx_RefNannySetupContext("LINEARREG_ANGLE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3291, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3292, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3293, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3293, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3364, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_INTERCEPT_Lookback(__pyx_v_timeperiod)); + __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_ANGLE_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3296, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3297, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3297, __pyx_L1_error) - __pyx_v_retCode = TA_LINEARREG_INTERCEPT(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_LINEARREG_ANGLE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_INTERCEPT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3298, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_ANGLE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -35996,7 +27903,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED P /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); @@ -36008,16 +27915,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_217LINEARREG_SLOPE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_221LINEARREG_INTERCEPT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_216LINEARREG_SLOPE, " LINEARREG_SLOPE(real[, timeperiod=?])\n\n Linear Regression Slope (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_217LINEARREG_SLOPE = {"LINEARREG_SLOPE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_217LINEARREG_SLOPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_216LINEARREG_SLOPE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_217LINEARREG_SLOPE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -36036,9 +27943,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("LINEARREG_SLOPE (wrapper)", 0); + __Pyx_RefNannySetupContext("LINEARREG_INTERCEPT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -36046,89 +27953,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3372, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3372, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3301, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3301, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "LINEARREG_SLOPE") < 0)) __PYX_ERR(3, 3301, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3372, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3372, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3303, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3374, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("LINEARREG_SLOPE", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3301, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("LINEARREG_INTERCEPT", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3372, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3303, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3374, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_220LINEARREG_INTERCEPT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_220LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -36140,42 +28039,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("LINEARREG_SLOPE", 0); + __Pyx_RefNannySetupContext("LINEARREG_INTERCEPT", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3322, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3323, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3324, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3324, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3395, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_SLOPE_Lookback(__pyx_v_timeperiod)); + __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_INTERCEPT_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3327, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3328, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3328, __pyx_L1_error) - __pyx_v_retCode = TA_LINEARREG_SLOPE(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_LINEARREG_INTERCEPT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_SLOPE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3329, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_INTERCEPT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3400, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -36188,7 +28080,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObj /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); @@ -36200,16 +28092,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_219LN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_223LINEARREG_SLOPE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_218LN, " LN(real)\n\n Vector Log Natural (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_219LN = {"LN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_219LN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_218LN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_219LN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -36217,19 +28109,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("LN (wrapper)", 0); + __Pyx_RefNannySetupContext("LINEARREG_SLOPE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -36237,71 +28130,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3403, __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(4, 3403, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3332, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "LN") < 0)) __PYX_ERR(3, 3332, __pyx_L3_error) + const Py_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) + 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) } } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3403, __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(4, 3403, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } } __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3405, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("LN", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 3332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("LINEARREG_SLOPE", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3403, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.LN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3334, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_218LN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3405, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_222LINEARREG_SLOPE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_222LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -36313,42 +28216,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_se PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("LN", 0); + __Pyx_RefNannySetupContext("LINEARREG_SLOPE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3351, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3352, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3353, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3353, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3426, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - __pyx_v_lookback = (__pyx_v_begidx + TA_LN_Lookback()); + __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_SLOPE_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3356, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3357, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3357, __pyx_L1_error) - __pyx_v_retCode = TA_LN(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_LINEARREG_SLOPE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3358, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_SLOPE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -36361,7 +28257,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_se /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.LN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); @@ -36373,16 +28269,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_221LOG10(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_225LN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_220LOG10, " LOG10(real)\n\n Vector Log10 (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_221LOG10 = {"LOG10", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_221LOG10, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_220LOG10}; -static PyObject *__pyx_pw_5talib_7_ta_lib_221LOG10(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -36400,9 +28296,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("LOG10 (wrapper)", 0); + __Pyx_RefNannySetupContext("LN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -36410,71 +28306,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3434, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3361, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "LOG10") < 0)) __PYX_ERR(3, 3361, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3434, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("LOG10", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 3361, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("LN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3434, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3363, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_220LOG10(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3436, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_224LN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_224LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -36486,42 +28376,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("LOG10", 0); + __Pyx_RefNannySetupContext("LN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3380, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3381, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3382, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3382, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3455, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - __pyx_v_lookback = (__pyx_v_begidx + TA_LOG10_Lookback()); + __pyx_v_lookback = (__pyx_v_begidx + TA_LN_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3385, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3386, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3386, __pyx_L1_error) - __pyx_v_retCode = TA_LOG10(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_LN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LOG10, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3387, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3460, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -36534,7 +28417,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LN", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); @@ -36546,16 +28429,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_223MA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_227LOG10(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_222MA, " MA(real[, timeperiod=?, matype=?])\n\n Moving average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n matype: 0 (Simple Moving Average)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_223MA = {"MA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_223MA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_222MA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_223MA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -36563,21 +28446,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - int __pyx_v_timeperiod; - int __pyx_v_matype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("MA (wrapper)", 0); + __Pyx_RefNannySetupContext("LOG10 (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -36585,105 +28466,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3463, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3390, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3390, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3390, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MA") < 0)) __PYX_ERR(3, 3390, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3463, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3392, __pyx_L3_error) - } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); - } - if (values[2]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3392, __pyx_L3_error) - } else { - __pyx_v_matype = ((int)((int)0)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MA", 0, 1, 3, __pyx_nargs); __PYX_ERR(3, 3390, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("LOG10", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3463, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.MA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3392, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_222MA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3465, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_226LOG10(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_226LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -36695,42 +28536,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_se PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("MA", 0); + __Pyx_RefNannySetupContext("LOG10", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3412, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3413, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3414, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3414, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3484, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); - __pyx_v_lookback = (__pyx_v_begidx + TA_MA_Lookback(__pyx_v_timeperiod, __pyx_v_matype)); + __pyx_v_lookback = (__pyx_v_begidx + TA_LOG10_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3417, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3418, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3418, __pyx_L1_error) - __pyx_v_retCode = TA_MA(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_LOG10(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3419, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LOG10, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -36743,7 +28577,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_se /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.MA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); @@ -36755,16 +28589,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_225MACD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_229MA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_224MACD, " MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\n Moving Average Convergence/Divergence (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastperiod: 12\n slowperiod: 26\n signalperiod: 9\n Outputs:\n macd\n macdsignal\n macdhist\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_225MACD = {"MACD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_225MACD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_224MACD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_225MACD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -36772,22 +28606,21 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - int __pyx_v_fastperiod; - int __pyx_v_slowperiod; - int __pyx_v_signalperiod; + int __pyx_v_timeperiod; + int __pyx_v_matype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("MACD (wrapper)", 0); + __Pyx_RefNannySetupContext("MA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -36795,121 +28628,299 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_signalperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3492, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3492, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3492, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3422, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3492, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3492, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3422, __pyx_L3_error) - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3492, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3494, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } + if (values[2]) { + __pyx_v_matype = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3494, __pyx_L3_error) + } else { + __pyx_v_matype = ((int)((int)0)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("MA", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 3492, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.MA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3494, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_228MA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_matype); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_228MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype) { + npy_intp __pyx_v_length; + int __pyx_v_begidx; + int __pyx_v_endidx; + int __pyx_v_lookback; + TA_RetCode __pyx_v_retCode; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + PyArrayObject *__pyx_v_outreal = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("MA", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); + + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3516, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; + + __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); + + __pyx_v_lookback = (__pyx_v_begidx + TA_MA_Lookback(__pyx_v_timeperiod, __pyx_v_matype)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + __pyx_v_retCode = TA_MA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3521, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_outreal); + __pyx_r = ((PyObject *)__pyx_v_outreal); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.MA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_outreal); + __Pyx_XDECREF((PyObject *)__pyx_v_real); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_231MACD(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_real = 0; + int __pyx_v_fastperiod; + int __pyx_v_slowperiod; + int __pyx_v_signalperiod; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("MACD (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3524, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3524, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3422, __pyx_L3_error) - } + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3524, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_signalperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3422, __pyx_L3_error) - } + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3524, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MACD") < 0)) __PYX_ERR(3, 3422, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3524, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3524, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3524, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3524, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3424, __pyx_L3_error) + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3526, __pyx_L3_error) } else { __pyx_v_fastperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3424, __pyx_L3_error) + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3526, __pyx_L3_error) } else { __pyx_v_slowperiod = ((int)((int)-2147483648)); } if (values[3]) { - __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3424, __pyx_L3_error) + __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3526, __pyx_L3_error) } else { __pyx_v_signalperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MACD", 0, 1, 4, __pyx_nargs); __PYX_ERR(3, 3422, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MACD", 0, 1, 4, __pyx_nargs); __PYX_ERR(4, 3524, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MACD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3424, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_224MACD(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3526, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_230MACD(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_224MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_230MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -36923,71 +28934,60 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_224MACD(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MACD", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3449, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3450, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3451, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3451, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3553, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MACD_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3454, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacd = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3455, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacdsignal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3456, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3457, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacd); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3457, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdsignal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3457, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdhist); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3457, __pyx_L1_error) - __pyx_v_retCode = TA_MACD(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback), (((double *)__pyx_t_6) + __pyx_v_lookback), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MACD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacd)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdsignal)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdhist)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3458, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3459, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3561, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outmacd); __Pyx_GIVEREF((PyObject *)__pyx_v_outmacd); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd))) __PYX_ERR(3, 3459, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd)) != (0)) __PYX_ERR(4, 3561, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outmacdsignal); __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdsignal); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal))) __PYX_ERR(3, 3459, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal)) != (0)) __PYX_ERR(4, 3561, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outmacdhist); __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdhist); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist))) __PYX_ERR(3, 3459, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist)) != (0)) __PYX_ERR(4, 3561, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -37010,16 +29010,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_224MACD(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_227MACDEXT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_233MACDEXT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_226MACDEXT, " MACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\n MACD with controllable MA type (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastperiod: 12\n fastmatype: 0\n slowperiod: 26\n slowmatype: 0\n signalperiod: 9\n signalmatype: 0\n Outputs:\n macd\n macdsignal\n macdhist\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_227MACDEXT = {"MACDEXT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_227MACDEXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_226MACDEXT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_227MACDEXT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -37045,7 +29045,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MACDEXT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -37053,169 +29053,146 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_fastmatype,&__pyx_n_s_slowperiod,&__pyx_n_s_slowmatype,&__pyx_n_s_signalperiod,&__pyx_n_s_signalmatype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3461, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3461, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastmatype); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3461, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3461, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowmatype); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3461, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_signalperiod); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3461, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 6: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_signalmatype); - if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3461, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MACDEXT") < 0)) __PYX_ERR(3, 3461, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3563, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3563, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3463, __pyx_L3_error) + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error) } else { __pyx_v_fastperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_fastmatype = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_fastmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3463, __pyx_L3_error) + __pyx_v_fastmatype = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_fastmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error) } else { __pyx_v_fastmatype = ((int)((int)0)); } if (values[3]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3463, __pyx_L3_error) + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error) } else { __pyx_v_slowperiod = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_slowmatype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_slowmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3463, __pyx_L3_error) + __pyx_v_slowmatype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_slowmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error) } else { __pyx_v_slowmatype = ((int)((int)0)); } if (values[5]) { - __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3463, __pyx_L3_error) + __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error) } else { __pyx_v_signalperiod = ((int)((int)-2147483648)); } if (values[6]) { - __pyx_v_signalmatype = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_signalmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3463, __pyx_L3_error) + __pyx_v_signalmatype = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_signalmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error) } else { __pyx_v_signalmatype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MACDEXT", 0, 1, 7, __pyx_nargs); __PYX_ERR(3, 3461, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MACDEXT", 0, 1, 7, __pyx_nargs); __PYX_ERR(4, 3563, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3463, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_226MACDEXT(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3565, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_232MACDEXT(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_226MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_232MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -37229,71 +29206,60 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_226MACDEXT(CYTHON_UNUSED PyObject *__p PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MACDEXT", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3491, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3492, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3493, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3493, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3595, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MACDEXT_Lookback(__pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3496, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacd = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3497, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacdsignal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3498, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3499, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacd); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3499, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdsignal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3499, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdhist); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3499, __pyx_L1_error) - __pyx_v_retCode = TA_MACDEXT(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback), (((double *)__pyx_t_6) + __pyx_v_lookback), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MACDEXT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacd)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdsignal)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdhist)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACDEXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3500, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACDEXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3501, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3603, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outmacd); __Pyx_GIVEREF((PyObject *)__pyx_v_outmacd); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd))) __PYX_ERR(3, 3501, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd)) != (0)) __PYX_ERR(4, 3603, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outmacdsignal); __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdsignal); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal))) __PYX_ERR(3, 3501, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal)) != (0)) __PYX_ERR(4, 3603, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outmacdhist); __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdhist); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist))) __PYX_ERR(3, 3501, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist)) != (0)) __PYX_ERR(4, 3603, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -37316,16 +29282,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_226MACDEXT(CYTHON_UNUSED PyObject *__p /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_229MACDFIX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_235MACDFIX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_228MACDFIX, " MACDFIX(real[, signalperiod=?])\n\n Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n signalperiod: 9\n Outputs:\n macd\n macdsignal\n macdhist\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_229MACDFIX = {"MACDFIX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_229MACDFIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_228MACDFIX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_229MACDFIX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -37346,7 +29312,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MACDFIX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -37354,89 +29320,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_signalperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3605, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3605, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3503, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_signalperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3503, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MACDFIX") < 0)) __PYX_ERR(3, 3503, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3605, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3605, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3505, __pyx_L3_error) + __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3607, __pyx_L3_error) } else { __pyx_v_signalperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MACDFIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3503, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MACDFIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3605, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3505, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_228MACDFIX(__pyx_self, __pyx_v_real, __pyx_v_signalperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3607, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_234MACDFIX(__pyx_self, __pyx_v_real, __pyx_v_signalperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_228MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_234MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -37450,71 +29408,60 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_228MACDFIX(CYTHON_UNUSED PyObject *__p PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MACDFIX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3528, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3630, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3529, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3530, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3530, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3632, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MACDFIX_Lookback(__pyx_v_signalperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3533, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3635, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacd = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3534, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3636, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacdsignal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3535, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3637, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3536, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacd); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3536, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdsignal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3536, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdhist); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3536, __pyx_L1_error) - __pyx_v_retCode = TA_MACDFIX(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback), (((double *)__pyx_t_6) + __pyx_v_lookback), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MACDFIX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacd)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdsignal)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdhist)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACDFIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3537, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACDFIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3639, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3538, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3640, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outmacd); __Pyx_GIVEREF((PyObject *)__pyx_v_outmacd); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd))) __PYX_ERR(3, 3538, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd)) != (0)) __PYX_ERR(4, 3640, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outmacdsignal); __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdsignal); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal))) __PYX_ERR(3, 3538, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal)) != (0)) __PYX_ERR(4, 3640, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outmacdhist); __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdhist); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist))) __PYX_ERR(3, 3538, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist)) != (0)) __PYX_ERR(4, 3640, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -37537,16 +29484,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_228MACDFIX(CYTHON_UNUSED PyObject *__p /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_231MAMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_237MAMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_230MAMA, " MAMA(real[, fastlimit=?, slowlimit=?])\n\n MESA Adaptive Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastlimit: 0.5\n slowlimit: 0.05\n Outputs:\n mama\n fama\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_231MAMA = {"MAMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_231MAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_230MAMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_231MAMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -37568,7 +29515,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MAMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -37576,105 +29523,94 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastlimit,&__pyx_n_s_slowlimit,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3642, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3642, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3642, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3540, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastlimit); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3540, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowlimit); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3540, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MAMA") < 0)) __PYX_ERR(3, 3540, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3642, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3642, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3642, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastlimit = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_fastlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 3542, __pyx_L3_error) + __pyx_v_fastlimit = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_fastlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 3644, __pyx_L3_error) } else { __pyx_v_fastlimit = ((double)((double)-4e37)); } if (values[2]) { - __pyx_v_slowlimit = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_slowlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 3542, __pyx_L3_error) + __pyx_v_slowlimit = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_slowlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 3644, __pyx_L3_error) } else { __pyx_v_slowlimit = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MAMA", 0, 1, 3, __pyx_nargs); __PYX_ERR(3, 3540, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MAMA", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 3642, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3542, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_230MAMA(__pyx_self, __pyx_v_real, __pyx_v_fastlimit, __pyx_v_slowlimit); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3644, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_236MAMA(__pyx_self, __pyx_v_real, __pyx_v_fastlimit, __pyx_v_slowlimit); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_230MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit) { +static PyObject *__pyx_pf_5talib_7_ta_lib_236MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -37687,61 +29623,52 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_230MAMA(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MAMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3564, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3666, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3565, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3566, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3566, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3668, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MAMA_Lookback(__pyx_v_fastlimit, __pyx_v_slowlimit)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3569, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3671, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmama = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3570, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outfama = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3571, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmama); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3571, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfama); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3571, __pyx_L1_error) - __pyx_v_retCode = TA_MAMA(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_fastlimit, __pyx_v_slowlimit, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MAMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastlimit, __pyx_v_slowlimit, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmama)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfama)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3572, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3573, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outmama); __Pyx_GIVEREF((PyObject *)__pyx_v_outmama); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmama))) __PYX_ERR(3, 3573, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmama)) != (0)) __PYX_ERR(4, 3675, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outfama); __Pyx_GIVEREF((PyObject *)__pyx_v_outfama); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfama))) __PYX_ERR(3, 3573, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfama)) != (0)) __PYX_ERR(4, 3675, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -37763,16 +29690,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_230MAMA(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_233MAVP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_239MAVP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_232MAVP, " MAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\n Moving average with variable period (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n periods: (any ndarray)\n Parameters:\n minperiod: 2\n maxperiod: 30\n matype: 0 (Simple Moving Average)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_233MAVP = {"MAVP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_233MAVP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_232MAVP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_233MAVP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -37796,7 +29723,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MAVP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -37804,78 +29731,58 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_periods,&__pyx_n_s_minperiod,&__pyx_n_s_maxperiod,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3677, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3575, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_periods)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3575, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MAVP", 0, 2, 5, 1); __PYX_ERR(3, 3575, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_minperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3575, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3575, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3575, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MAVP") < 0)) __PYX_ERR(3, 3575, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3677, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3677, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -37883,57 +29790,56 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_real = ((PyArrayObject *)values[0]); __pyx_v_periods = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_minperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_minperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3577, __pyx_L3_error) + __pyx_v_minperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_minperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3679, __pyx_L3_error) } else { __pyx_v_minperiod = ((int)((int)-2147483648)); } if (values[3]) { - __pyx_v_maxperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_maxperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3577, __pyx_L3_error) + __pyx_v_maxperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_maxperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3679, __pyx_L3_error) } else { __pyx_v_maxperiod = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3577, __pyx_L3_error) + __pyx_v_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3679, __pyx_L3_error) } else { __pyx_v_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MAVP", 0, 2, 5, __pyx_nargs); __PYX_ERR(3, 3575, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MAVP", 0, 2, 5, __pyx_nargs); __PYX_ERR(4, 3677, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3577, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_periods), __pyx_ptype_5numpy_ndarray, 0, "periods", 0))) __PYX_ERR(3, 3577, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_232MAVP(__pyx_self, __pyx_v_real, __pyx_v_periods, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3679, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_periods), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "periods", 0))) __PYX_ERR(4, 3679, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_238MAVP(__pyx_self, __pyx_v_real, __pyx_v_periods, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_232MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_238MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -37946,10 +29852,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_232MAVP(CYTHON_UNUSED PyObject *__pyx_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -37957,39 +29860,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_232MAVP(CYTHON_UNUSED PyObject *__pyx_ __Pyx_INCREF((PyObject *)__pyx_v_real); __Pyx_INCREF((PyObject *)__pyx_v_periods); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3599, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3701, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_periods)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3600, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_periods)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3702, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 3601, __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_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3602, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3602, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3602, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MAVP_Lookback(__pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3605, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3707, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3606, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3606, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3606, __pyx_L1_error) - __pyx_v_retCode = TA_MAVP(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MAVP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods)) + __pyx_v_begidx), __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAVP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3607, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAVP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3709, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -38015,16 +29913,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_232MAVP(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_235MAX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_241MAX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_234MAX, " MAX(real[, timeperiod=?])\n\n Highest value over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_235MAX = {"MAX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_235MAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_234MAX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_235MAX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -38045,7 +29943,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MAX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -38053,89 +29951,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3712, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3712, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3610, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3610, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MAX") < 0)) __PYX_ERR(3, 3610, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3712, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3712, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3612, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3714, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3610, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3712, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MAX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3612, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_234MAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3714, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_240MAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_234MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_240MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -38147,42 +30037,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_234MAX(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MAX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3631, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3733, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3632, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3633, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3633, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3735, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MAX_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3636, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3637, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3637, __pyx_L1_error) - __pyx_v_retCode = TA_MAX(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MAX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3638, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -38207,16 +30090,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_234MAX(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_237MAXINDEX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_243MAXINDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_236MAXINDEX, " MAXINDEX(real[, timeperiod=?])\n\n Index of highest value over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_237MAXINDEX = {"MAXINDEX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_237MAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_236MAXINDEX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_237MAXINDEX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -38237,7 +30120,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MAXINDEX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -38245,89 +30128,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3743, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3743, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3641, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3641, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MAXINDEX") < 0)) __PYX_ERR(3, 3641, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3743, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3743, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3643, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3745, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3641, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3743, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3643, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_236MAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3745, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_242MAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_236MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_242MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -38341,55 +30216,47 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_236MAXINDEX(CYTHON_UNUSED PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - npy_intp __pyx_t_6; - int __pyx_t_7; + npy_int __pyx_t_2; + npy_intp __pyx_t_3; + int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MAXINDEX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3662, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3663, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3664, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3664, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3766, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MAXINDEX_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3667, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3668, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3668, __pyx_L1_error) - __pyx_v_retCode = TA_MAXINDEX(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MAXINDEX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3669, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3771, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3670, __pyx_L1_error) - __pyx_v_outinteger_data = ((int *)__pyx_t_5); + __pyx_v_outinteger_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)); - __pyx_t_6 = __pyx_v_length; - for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_6; __pyx_v_i++) { + __pyx_t_3 = __pyx_v_length; + for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { - __pyx_t_7 = __pyx_v_i; - (__pyx_v_outinteger_data[__pyx_t_7]) = ((__pyx_v_outinteger_data[__pyx_t_7]) + __pyx_v_begidx); + __pyx_t_4 = __pyx_v_i; + (__pyx_v_outinteger_data[__pyx_t_4]) = ((__pyx_v_outinteger_data[__pyx_t_4]) + __pyx_v_begidx); } __Pyx_XDECREF(__pyx_r); @@ -38413,16 +30280,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_236MAXINDEX(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_239MEDPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_245MEDPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_238MEDPRICE, " MEDPRICE(high, low)\n\n Median Price (Price Transform)\n\n Inputs:\n prices: ['high', 'low']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_239MEDPRICE = {"MEDPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_239MEDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_238MEDPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_239MEDPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -38443,7 +30310,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MEDPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -38451,86 +30318,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3777, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3777, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3675, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3675, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MEDPRICE", 1, 2, 2, 1); __PYX_ERR(3, 3675, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MEDPRICE") < 0)) __PYX_ERR(3, 3675, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3777, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3777, __pyx_L3_error) } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MEDPRICE", 1, 2, 2, __pyx_nargs); __PYX_ERR(3, 3675, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MEDPRICE", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 3777, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 3677, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 3677, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_238MEDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3779, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3779, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_244MEDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low) { +static PyObject *__pyx_pf_5talib_7_ta_lib_244MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -38543,10 +30397,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -38554,39 +30405,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__ __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3694, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3695, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3797, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 3696, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3697, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3697, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3697, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MEDPRICE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3700, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3802, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3701, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3701, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3701, __pyx_L1_error) - __pyx_v_retCode = TA_MEDPRICE(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MEDPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MEDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3702, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MEDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3804, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -38612,16 +30458,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_241MFI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_247MFI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_240MFI, " MFI(high, low, close, volume[, timeperiod=?])\n\n Money Flow Index (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close', 'volume']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_241MFI = {"MFI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_241MFI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_240MFI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_241MFI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -38645,7 +30491,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MFI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -38653,82 +30499,54 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3807, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3807, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3807, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3807, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3807, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3705, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3705, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, 1); __PYX_ERR(3, 3705, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3705, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, 2); __PYX_ERR(3, 3705, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_volume)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3705, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, 3); __PYX_ERR(3, 3705, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3705, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MFI") < 0)) __PYX_ERR(3, 3705, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3807, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3807, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3807, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3807, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3807, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -38738,49 +30556,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_close = ((PyArrayObject *)values[2]); __pyx_v_volume = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3707, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3809, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, __pyx_nargs); __PYX_ERR(3, 3705, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 3807, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MFI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 3707, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 3707, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 3707, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(3, 3707, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_240MFI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3809, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3809, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 3809, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 3809, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_246MFI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_246MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -38793,12 +30610,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_s __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_int __pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -38808,53 +30620,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_s __Pyx_INCREF((PyObject *)__pyx_v_close); __Pyx_INCREF((PyObject *)__pyx_v_volume); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3726, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3727, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3829, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3728, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3729, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 3730, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3731, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3731, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3731, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3731, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5), ((double *)__pyx_t_6)); if (unlikely(__pyx_t_7 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3731, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_7; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MFI_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3734, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3836, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3735, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3735, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3735, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3735, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3735, __pyx_L1_error) - __pyx_v_retCode = TA_MFI(0, __pyx_v_endidx, (((double *)__pyx_t_6) + __pyx_v_begidx), (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MFI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MFI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3736, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MFI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3838, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -38882,16 +30685,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_243MIDPOINT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_249MIDPOINT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_242MIDPOINT, " MIDPOINT(real[, timeperiod=?])\n\n MidPoint over period (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_243MIDPOINT = {"MIDPOINT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_243MIDPOINT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_242MIDPOINT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_243MIDPOINT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -38912,7 +30715,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MIDPOINT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -38920,89 +30723,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3841, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3841, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3739, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3739, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MIDPOINT") < 0)) __PYX_ERR(3, 3739, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3841, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3841, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3741, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3843, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MIDPOINT", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3739, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MIDPOINT", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3841, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3741, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_242MIDPOINT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3843, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_248MIDPOINT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_242MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_248MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -39014,42 +30809,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_242MIDPOINT(CYTHON_UNUSED PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MIDPOINT", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3760, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3862, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3761, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3762, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3762, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3864, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MIDPOINT_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3765, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3867, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3766, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3766, __pyx_L1_error) - __pyx_v_retCode = TA_MIDPOINT(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MIDPOINT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIDPOINT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3767, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIDPOINT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3869, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -39074,16 +30862,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_242MIDPOINT(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_245MIDPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_251MIDPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_244MIDPRICE, " MIDPRICE(high, low[, timeperiod=?])\n\n Midpoint Price over period (Overlap Studies)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_245MIDPRICE = {"MIDPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_245MIDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_244MIDPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_245MIDPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -39105,7 +30893,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MIDPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -39113,56 +30901,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3872, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3872, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3872, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3770, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3770, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MIDPRICE", 0, 2, 3, 1); __PYX_ERR(3, 3770, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3770, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MIDPRICE") < 0)) __PYX_ERR(3, 3770, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3872, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3872, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3872, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -39170,47 +30944,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3772, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3874, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MIDPRICE", 0, 2, 3, __pyx_nargs); __PYX_ERR(3, 3770, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MIDPRICE", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 3872, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 3772, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 3772, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_244MIDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3874, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3874, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_250MIDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_250MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -39223,10 +30996,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -39234,39 +31004,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__ __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3791, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3792, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 3793, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3794, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3794, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3794, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MIDPRICE_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3798, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3798, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3798, __pyx_L1_error) - __pyx_v_retCode = TA_MIDPRICE(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MIDPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3799, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -39292,16 +31057,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_247MIN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_253MIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_246MIN, " MIN(real[, timeperiod=?])\n\n Lowest value over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_247MIN = {"MIN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_247MIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_246MIN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_247MIN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -39322,7 +31087,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MIN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -39330,89 +31095,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3904, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3904, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3802, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3802, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MIN") < 0)) __PYX_ERR(3, 3802, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3904, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3904, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3804, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3906, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MIN", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3802, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MIN", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3904, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MIN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3804, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_246MIN(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3906, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_252MIN(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_246MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_252MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -39424,42 +31181,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_246MIN(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MIN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3823, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3925, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3824, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3825, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3825, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3927, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MIN_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3828, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3829, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3829, __pyx_L1_error) - __pyx_v_retCode = TA_MIN(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MIN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3830, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3932, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -39484,16 +31234,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_246MIN(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_249MININDEX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_255MININDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_248MININDEX, " MININDEX(real[, timeperiod=?])\n\n Index of lowest value over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_249MININDEX = {"MININDEX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_249MININDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_248MININDEX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_249MININDEX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -39514,7 +31264,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MININDEX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -39522,89 +31272,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3935, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3935, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3833, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3833, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MININDEX") < 0)) __PYX_ERR(3, 3833, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3935, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3935, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3835, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3937, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MININDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3833, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MININDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3935, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3835, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_248MININDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3937, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_254MININDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_248MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_254MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -39618,55 +31360,47 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_248MININDEX(CYTHON_UNUSED PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - npy_intp __pyx_t_6; - int __pyx_t_7; + npy_int __pyx_t_2; + npy_intp __pyx_t_3; + int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MININDEX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3854, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3956, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3855, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3856, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3856, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3958, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MININDEX_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3859, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3961, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3860, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3860, __pyx_L1_error) - __pyx_v_retCode = TA_MININDEX(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MININDEX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MININDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3861, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MININDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3963, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3862, __pyx_L1_error) - __pyx_v_outinteger_data = ((int *)__pyx_t_5); + __pyx_v_outinteger_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)); - __pyx_t_6 = __pyx_v_length; - for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_6; __pyx_v_i++) { + __pyx_t_3 = __pyx_v_length; + for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { - __pyx_t_7 = __pyx_v_i; - (__pyx_v_outinteger_data[__pyx_t_7]) = ((__pyx_v_outinteger_data[__pyx_t_7]) + __pyx_v_begidx); + __pyx_t_4 = __pyx_v_i; + (__pyx_v_outinteger_data[__pyx_t_4]) = ((__pyx_v_outinteger_data[__pyx_t_4]) + __pyx_v_begidx); } __Pyx_XDECREF(__pyx_r); @@ -39690,16 +31424,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_248MININDEX(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_251MINMAX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_257MINMAX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_250MINMAX, " MINMAX(real[, timeperiod=?])\n\n Lowest and highest values over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n min\n max\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_251MINMAX = {"MINMAX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_251MINMAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_250MINMAX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_251MINMAX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -39720,7 +31454,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MINMAX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -39728,89 +31462,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3969, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3969, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3867, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3867, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MINMAX") < 0)) __PYX_ERR(3, 3867, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3969, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3969, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3869, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3971, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MINMAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3867, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MINMAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3969, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3869, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_250MINMAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3971, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_256MINMAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_250MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_256MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -39823,61 +31549,52 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_250MINMAX(CYTHON_UNUSED PyObject *__py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MINMAX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3890, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3992, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3891, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3892, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3892, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3994, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MINMAX_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3895, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmin = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3896, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3998, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmax = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3897, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmin); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3897, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmax); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3897, __pyx_L1_error) - __pyx_v_retCode = TA_MINMAX(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MINMAX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmin)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmax)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINMAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3898, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINMAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3899, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outmin); __Pyx_GIVEREF((PyObject *)__pyx_v_outmin); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmin))) __PYX_ERR(3, 3899, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmin)) != (0)) __PYX_ERR(4, 4001, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outmax); __Pyx_GIVEREF((PyObject *)__pyx_v_outmax); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmax))) __PYX_ERR(3, 3899, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmax)) != (0)) __PYX_ERR(4, 4001, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -39899,16 +31616,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_250MINMAX(CYTHON_UNUSED PyObject *__py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_253MINMAXINDEX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_259MINMAXINDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_252MINMAXINDEX, " MINMAXINDEX(real[, timeperiod=?])\n\n Indexes of lowest and highest values over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n minidx\n maxidx\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_253MINMAXINDEX = {"MINMAXINDEX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_253MINMAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_252MINMAXINDEX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_253MINMAXINDEX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -39929,7 +31646,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MINMAXINDEX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -39937,89 +31654,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4003, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4003, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3901, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3901, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MINMAXINDEX") < 0)) __PYX_ERR(3, 3901, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4003, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4003, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3903, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4005, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MINMAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 3901, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MINMAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4003, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3903, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4005, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_258MINMAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_258MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -40035,83 +31744,72 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; - npy_intp __pyx_t_7; - int __pyx_t_8; + npy_int __pyx_t_2; + npy_intp __pyx_t_3; + int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MINMAXINDEX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3924, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4026, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3925, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3926, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3926, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4028, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MINMAXINDEX_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3929, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4031, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outminidx = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3930, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4032, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmaxidx = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3931, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outminidx); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3931, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmaxidx); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3931, __pyx_L1_error) - __pyx_v_retCode = TA_MINMAXINDEX(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_t_5) + __pyx_v_lookback), (((int *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MINMAXINDEX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outminidx)) + __pyx_v_lookback), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmaxidx)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINMAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3932, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINMAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4034, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outminidx); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3933, __pyx_L1_error) - __pyx_v_outminidx_data = ((int *)__pyx_t_6); + __pyx_v_outminidx_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outminidx)); - __pyx_t_7 = __pyx_v_length; - for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_7; __pyx_v_i++) { + __pyx_t_3 = __pyx_v_length; + for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { - __pyx_t_8 = __pyx_v_i; - (__pyx_v_outminidx_data[__pyx_t_8]) = ((__pyx_v_outminidx_data[__pyx_t_8]) + __pyx_v_begidx); + __pyx_t_4 = __pyx_v_i; + (__pyx_v_outminidx_data[__pyx_t_4]) = ((__pyx_v_outminidx_data[__pyx_t_4]) + __pyx_v_begidx); } - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmaxidx); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3936, __pyx_L1_error) - __pyx_v_outmaxidx_data = ((int *)__pyx_t_6); + __pyx_v_outmaxidx_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmaxidx)); - __pyx_t_7 = __pyx_v_length; - for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_7; __pyx_v_i++) { + __pyx_t_3 = __pyx_v_length; + for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { - __pyx_t_8 = __pyx_v_i; - (__pyx_v_outmaxidx_data[__pyx_t_8]) = ((__pyx_v_outmaxidx_data[__pyx_t_8]) + __pyx_v_begidx); + __pyx_t_4 = __pyx_v_i; + (__pyx_v_outmaxidx_data[__pyx_t_4]) = ((__pyx_v_outmaxidx_data[__pyx_t_4]) + __pyx_v_begidx); } __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3939, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4041, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outminidx); __Pyx_GIVEREF((PyObject *)__pyx_v_outminidx); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outminidx))) __PYX_ERR(3, 3939, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outminidx)) != (0)) __PYX_ERR(4, 4041, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outmaxidx); __Pyx_GIVEREF((PyObject *)__pyx_v_outmaxidx); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmaxidx))) __PYX_ERR(3, 3939, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmaxidx)) != (0)) __PYX_ERR(4, 4041, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -40133,16 +31831,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_255MINUS_DI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_261MINUS_DI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_254MINUS_DI, " MINUS_DI(high, low, close[, timeperiod=?])\n\n Minus Directional Indicator (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_255MINUS_DI = {"MINUS_DI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_255MINUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_254MINUS_DI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_255MINUS_DI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -40165,7 +31863,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MINUS_DI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -40173,69 +31871,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4043, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4043, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4043, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4043, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3941, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3941, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, 1); __PYX_ERR(3, 3941, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3941, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, 2); __PYX_ERR(3, 3941, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3941, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MINUS_DI") < 0)) __PYX_ERR(3, 3941, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4043, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4043, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4043, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4043, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -40244,48 +31921,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3943, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4045, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(3, 3941, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 4043, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 3943, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 3943, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 3943, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_254MINUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4045, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4045, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4045, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_260MINUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_254MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_260MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -40298,11 +31974,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_254MINUS_DI(CYTHON_UNUSED PyObject *__ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -40311,46 +31983,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_254MINUS_DI(CYTHON_UNUSED PyObject *__ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3962, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3963, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4065, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3964, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4066, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 3965, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3966, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3966, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3966, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3966, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MINUS_DI_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3969, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4071, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3970, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3970, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3970, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3970, __pyx_L1_error) - __pyx_v_retCode = TA_MINUS_DI(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MINUS_DI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3971, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4073, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -40377,16 +32042,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_254MINUS_DI(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_257MINUS_DM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_263MINUS_DM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_256MINUS_DM, " MINUS_DM(high, low[, timeperiod=?])\n\n Minus Directional Movement (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_257MINUS_DM = {"MINUS_DM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_257MINUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_256MINUS_DM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_257MINUS_DM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -40408,7 +32073,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MINUS_DM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -40416,56 +32081,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4076, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4076, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4076, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3974, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3974, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MINUS_DM", 0, 2, 3, 1); __PYX_ERR(3, 3974, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3974, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MINUS_DM") < 0)) __PYX_ERR(3, 3974, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4076, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4076, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4076, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -40473,47 +32124,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3976, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4078, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MINUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(3, 3974, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MINUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 4076, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 3976, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 3976, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_256MINUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4078, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4078, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_262MINUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_256MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_262MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -40526,10 +32176,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_256MINUS_DM(CYTHON_UNUSED PyObject *__ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -40537,39 +32184,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_256MINUS_DM(CYTHON_UNUSED PyObject *__ __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3995, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3996, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4098, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 3997, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3998, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 3998, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3998, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MINUS_DM_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4001, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4002, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4002, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4002, __pyx_L1_error) - __pyx_v_retCode = TA_MINUS_DM(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MINUS_DM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4003, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -40595,16 +32237,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_256MINUS_DM(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_259MOM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_265MOM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_258MOM, " MOM(real[, timeperiod=?])\n\n Momentum (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_259MOM = {"MOM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_259MOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_258MOM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_259MOM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -40625,7 +32267,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MOM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -40633,89 +32275,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4108, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4108, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4006, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4006, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MOM") < 0)) __PYX_ERR(3, 4006, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4108, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4108, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4008, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4110, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MOM", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4006, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MOM", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4108, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MOM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4008, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_258MOM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4110, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_264MOM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_258MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_264MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -40727,42 +32361,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_258MOM(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MOM", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4027, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4028, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4029, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4029, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4131, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MOM_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4032, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4033, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4033, __pyx_L1_error) - __pyx_v_retCode = TA_MOM(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MOM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4034, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -40787,16 +32414,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_258MOM(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_261MULT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_267MULT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_260MULT, " MULT(real0, real1)\n\n Vector Arithmetic Mult (Math Operators)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_261MULT = {"MULT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_261MULT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_260MULT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_261MULT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -40817,7 +32444,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MULT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -40825,86 +32452,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4139, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4139, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4037, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4037, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("MULT", 1, 2, 2, 1); __PYX_ERR(3, 4037, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "MULT") < 0)) __PYX_ERR(3, 4037, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4139, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4139, __pyx_L3_error) } __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("MULT", 1, 2, 2, __pyx_nargs); __PYX_ERR(3, 4037, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("MULT", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 4139, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.MULT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 4039, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 4039, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_260MULT(__pyx_self, __pyx_v_real0, __pyx_v_real1); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 4141, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 4141, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_266MULT(__pyx_self, __pyx_v_real0, __pyx_v_real1); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { +static PyObject *__pyx_pf_5talib_7_ta_lib_266MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -40917,10 +32531,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -40928,39 +32539,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_ __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4057, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4058, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4059, __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_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4060, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4060, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4060, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_MULT_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4063, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4064, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4064, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4064, __pyx_L1_error) - __pyx_v_retCode = TA_MULT(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_MULT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MULT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4065, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MULT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -40986,16 +32592,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_263NATR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_269NATR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_262NATR, " NATR(high, low, close[, timeperiod=?])\n\n Normalized Average True Range (Volatility Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_263NATR = {"NATR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_263NATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_262NATR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_263NATR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -41018,7 +32624,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("NATR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -41026,69 +32632,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4170, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4170, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4170, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4170, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4068, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4068, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, 1); __PYX_ERR(3, 4068, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4068, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, 2); __PYX_ERR(3, 4068, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4068, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "NATR") < 0)) __PYX_ERR(3, 4068, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4170, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4170, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4170, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4170, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -41097,48 +32682,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4070, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4172, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(3, 4068, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 4170, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.NATR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4070, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4070, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4070, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_262NATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4172, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4172, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4172, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_268NATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_268NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -41151,11 +32735,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -41164,46 +32744,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4089, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4191, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4090, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4192, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4091, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4092, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4093, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4093, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4093, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4093, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_NATR_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4096, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4097, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4097, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4097, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4097, __pyx_L1_error) - __pyx_v_retCode = TA_NATR(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_NATR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_NATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_NATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -41230,16 +32803,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_265OBV(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_271OBV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_264OBV, " OBV(real, volume)\n\n On Balance Volume (Volume Indicators)\n\n Inputs:\n real: (any ndarray)\n prices: ['volume']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_265OBV = {"OBV", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_265OBV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_264OBV}; -static PyObject *__pyx_pw_5talib_7_ta_lib_265OBV(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -41260,7 +32833,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("OBV (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -41268,86 +32841,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_volume,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4203, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4203, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4101, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_volume)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4101, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("OBV", 1, 2, 2, 1); __PYX_ERR(3, 4101, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "OBV") < 0)) __PYX_ERR(3, 4101, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4203, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4203, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); __pyx_v_volume = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("OBV", 1, 2, 2, __pyx_nargs); __PYX_ERR(3, 4101, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("OBV", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 4203, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.OBV", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4103, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(3, 4103, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_264OBV(__pyx_self, __pyx_v_real, __pyx_v_volume); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4205, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 4205, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_270OBV(__pyx_self, __pyx_v_real, __pyx_v_volume); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_264OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume) { +static PyObject *__pyx_pf_5talib_7_ta_lib_270OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -41360,10 +32920,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_264OBV(CYTHON_UNUSED PyObject *__pyx_s __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -41371,39 +32928,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_264OBV(CYTHON_UNUSED PyObject *__pyx_s __Pyx_INCREF((PyObject *)__pyx_v_real); __Pyx_INCREF((PyObject *)__pyx_v_volume); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4121, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4122, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4123, __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_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4124, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4124, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4124, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_OBV_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4127, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4128, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4128, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4128, __pyx_L1_error) - __pyx_v_retCode = TA_OBV(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_OBV(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_OBV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4129, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_OBV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -41429,16 +32981,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_264OBV(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_267PLUS_DI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_273PLUS_DI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_266PLUS_DI, " PLUS_DI(high, low, close[, timeperiod=?])\n\n Plus Directional Indicator (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_267PLUS_DI = {"PLUS_DI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_267PLUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_266PLUS_DI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_267PLUS_DI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -41461,7 +33013,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("PLUS_DI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -41469,69 +33021,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4234, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4234, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4234, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4234, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4132, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4132, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, 1); __PYX_ERR(3, 4132, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4132, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, 2); __PYX_ERR(3, 4132, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4132, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "PLUS_DI") < 0)) __PYX_ERR(3, 4132, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4234, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4234, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4234, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4234, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -41540,48 +33071,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4134, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4236, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(3, 4132, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 4234, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4134, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4134, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4134, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_266PLUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4236, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4236, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4236, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_272PLUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_272PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -41594,11 +33124,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__p __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -41607,46 +33133,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__p __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4153, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4154, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4155, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4156, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4157, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4157, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4157, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4157, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_PLUS_DI_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4160, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4161, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4161, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4161, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4161, __pyx_L1_error) - __pyx_v_retCode = TA_PLUS_DI(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_PLUS_DI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PLUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4162, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PLUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4264, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -41673,16 +33192,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__p /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_269PLUS_DM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_275PLUS_DM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_268PLUS_DM, " PLUS_DM(high, low[, timeperiod=?])\n\n Plus Directional Movement (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_269PLUS_DM = {"PLUS_DM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_269PLUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_268PLUS_DM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_269PLUS_DM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -41704,7 +33223,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("PLUS_DM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -41712,56 +33231,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4267, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4267, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4267, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4165, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4165, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("PLUS_DM", 0, 2, 3, 1); __PYX_ERR(3, 4165, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4165, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "PLUS_DM") < 0)) __PYX_ERR(3, 4165, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4267, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4267, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4267, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -41769,47 +33274,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4167, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4269, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("PLUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(3, 4165, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("PLUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 4267, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4167, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4167, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_268PLUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4269, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4269, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_274PLUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_274PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -41822,10 +33326,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__p __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -41833,39 +33334,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__p __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4186, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4187, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4289, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4188, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4189, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4189, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4189, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_PLUS_DM_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4192, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4193, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4193, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4193, __pyx_L1_error) - __pyx_v_retCode = TA_PLUS_DM(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_PLUS_DM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PLUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4194, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PLUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -41891,16 +33387,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__p /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_271PPO(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_277PPO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_270PPO, " PPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\n Percentage Price Oscillator (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_271PPO = {"PPO", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_271PPO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_270PPO}; -static PyObject *__pyx_pw_5talib_7_ta_lib_271PPO(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -41923,7 +33419,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("PPO (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -41931,121 +33427,107 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4299, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4299, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4299, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4299, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4197, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4197, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4197, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4197, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "PPO") < 0)) __PYX_ERR(3, 4197, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4299, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4299, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4299, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4299, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4199, __pyx_L3_error) + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4301, __pyx_L3_error) } else { __pyx_v_fastperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4199, __pyx_L3_error) + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4301, __pyx_L3_error) } else { __pyx_v_slowperiod = ((int)((int)-2147483648)); } if (values[3]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4199, __pyx_L3_error) + __pyx_v_matype = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4301, __pyx_L3_error) } else { __pyx_v_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("PPO", 0, 1, 4, __pyx_nargs); __PYX_ERR(3, 4197, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("PPO", 0, 1, 4, __pyx_nargs); __PYX_ERR(4, 4299, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.PPO", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4199, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_270PPO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4301, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_276PPO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_270PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_276PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -42057,42 +33539,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_270PPO(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PPO", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4220, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4221, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4222, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4222, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4324, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_PPO_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4225, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4226, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4226, __pyx_L1_error) - __pyx_v_retCode = TA_PPO(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_PPO(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PPO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4227, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PPO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -42117,16 +33592,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_270PPO(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_273ROC(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_279ROC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_272ROC, " ROC(real[, timeperiod=?])\n\n Rate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_273ROC = {"ROC", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_273ROC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_272ROC}; -static PyObject *__pyx_pw_5talib_7_ta_lib_273ROC(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -42147,7 +33622,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ROC (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -42155,89 +33630,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4332, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4332, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4230, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4230, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ROC") < 0)) __PYX_ERR(3, 4230, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4332, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4332, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4232, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4334, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ROC", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4230, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ROC", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4332, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ROC", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4232, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_272ROC(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4334, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_278ROC(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_272ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_278ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -42249,42 +33716,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_272ROC(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ROC", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4251, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4252, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4253, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4253, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4355, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ROC_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4256, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4257, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4257, __pyx_L1_error) - __pyx_v_retCode = TA_ROC(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ROC(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4258, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -42309,16 +33769,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_272ROC(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_275ROCP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_281ROCP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_274ROCP, " ROCP(real[, timeperiod=?])\n\n Rate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_275ROCP = {"ROCP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_275ROCP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_274ROCP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_275ROCP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -42339,7 +33799,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ROCP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -42347,89 +33807,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4363, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4363, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4261, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4261, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ROCP") < 0)) __PYX_ERR(3, 4261, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4363, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4363, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4263, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4365, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ROCP", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4261, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ROCP", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4363, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4263, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_274ROCP(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4365, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_280ROCP(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_274ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_280ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -42441,42 +33893,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_274ROCP(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ROCP", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4282, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4283, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4284, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4284, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4386, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ROCP_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4287, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4288, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4288, __pyx_L1_error) - __pyx_v_retCode = TA_ROCP(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ROCP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4289, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -42501,16 +33946,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_274ROCP(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_277ROCR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_283ROCR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_276ROCR, " ROCR(real[, timeperiod=?])\n\n Rate of change ratio: (real/prevPrice) (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_277ROCR = {"ROCR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_277ROCR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_276ROCR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_277ROCR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -42531,7 +33976,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ROCR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -42539,89 +33984,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4394, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4394, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4292, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4292, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ROCR") < 0)) __PYX_ERR(3, 4292, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4394, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4394, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4294, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4396, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ROCR", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4292, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ROCR", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4394, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4294, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_276ROCR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4396, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_282ROCR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_276ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_282ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -42633,42 +34070,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_276ROCR(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ROCR", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4313, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4415, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4314, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4315, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4315, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4417, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ROCR_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4318, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4319, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4319, __pyx_L1_error) - __pyx_v_retCode = TA_ROCR(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ROCR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4320, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -42693,16 +34123,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_276ROCR(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_279ROCR100(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_285ROCR100(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_278ROCR100, " ROCR100(real[, timeperiod=?])\n\n Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_279ROCR100 = {"ROCR100", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_279ROCR100, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_278ROCR100}; -static PyObject *__pyx_pw_5talib_7_ta_lib_279ROCR100(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -42723,7 +34153,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ROCR100 (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -42731,89 +34161,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4425, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4425, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4323, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4323, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ROCR100") < 0)) __PYX_ERR(3, 4323, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4425, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4425, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4325, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4427, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ROCR100", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4323, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ROCR100", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4425, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4325, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_278ROCR100(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4427, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_284ROCR100(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_278ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_284ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -42825,42 +34247,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_278ROCR100(CYTHON_UNUSED PyObject *__p PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ROCR100", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4344, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4345, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4346, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4346, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4448, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ROCR100_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4349, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4350, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4350, __pyx_L1_error) - __pyx_v_retCode = TA_ROCR100(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ROCR100(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCR100, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4351, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCR100, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -42885,16 +34300,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_278ROCR100(CYTHON_UNUSED PyObject *__p /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_281RSI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_287RSI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_280RSI, " RSI(real[, timeperiod=?])\n\n Relative Strength Index (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_281RSI = {"RSI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_281RSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_280RSI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_281RSI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -42915,7 +34330,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("RSI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -42923,89 +34338,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4456, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4456, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4354, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4354, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "RSI") < 0)) __PYX_ERR(3, 4354, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4456, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4456, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4356, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4458, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("RSI", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4354, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("RSI", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4456, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.RSI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4356, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_280RSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4458, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_286RSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_280RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_286RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -43017,42 +34424,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_280RSI(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("RSI", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4375, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4376, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4377, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4377, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4479, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_RSI_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4380, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4381, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4381, __pyx_L1_error) - __pyx_v_retCode = TA_RSI(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_RSI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_RSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4382, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_RSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4484, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -43077,16 +34477,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_280RSI(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_283SAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_289SAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_282SAR, " SAR(high, low[, acceleration=?, maximum=?])\n\n Parabolic SAR (Overlap Studies)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n acceleration: 0.02\n maximum: 0.2\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_283SAR = {"SAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_283SAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_282SAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_283SAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -43109,7 +34509,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("SAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -43117,67 +34517,50 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_acceleration,&__pyx_n_s_maximum,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4487, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4487, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4487, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4487, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4385, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4385, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("SAR", 0, 2, 4, 1); __PYX_ERR(3, 4385, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_acceleration); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4385, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maximum); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4385, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "SAR") < 0)) __PYX_ERR(3, 4385, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4487, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4487, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4487, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4487, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -43185,52 +34568,51 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_acceleration = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_acceleration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4387, __pyx_L3_error) + __pyx_v_acceleration = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_acceleration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4489, __pyx_L3_error) } else { __pyx_v_acceleration = ((double)((double)0.02)); } if (values[3]) { - __pyx_v_maximum = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_maximum == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4387, __pyx_L3_error) + __pyx_v_maximum = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_maximum == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4489, __pyx_L3_error) } else { __pyx_v_maximum = ((double)((double)0.2)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("SAR", 0, 2, 4, __pyx_nargs); __PYX_ERR(3, 4385, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("SAR", 0, 2, 4, __pyx_nargs); __PYX_ERR(4, 4487, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.SAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4387, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4387, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_282SAR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_acceleration, __pyx_v_maximum); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4489, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4489, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_288SAR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_acceleration, __pyx_v_maximum); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum) { +static PyObject *__pyx_pf_5talib_7_ta_lib_288SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -43243,10 +34625,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_s __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -43254,39 +34633,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_s __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4407, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4509, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4408, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4510, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4409, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4410, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4410, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4410, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_SAR_Lookback(__pyx_v_acceleration, __pyx_v_maximum)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4413, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4414, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4414, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4414, __pyx_L1_error) - __pyx_v_retCode = TA_SAR(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_acceleration, __pyx_v_maximum, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_SAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_acceleration, __pyx_v_maximum, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4415, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -43312,16 +34686,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_285SAREXT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_291SAREXT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_284SAREXT, " SAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\n Parabolic SAR - Extended (Overlap Studies)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\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\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_285SAREXT = {"SAREXT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_285SAREXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_284SAREXT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_285SAREXT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -43350,7 +34724,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("SAREXT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -43358,133 +34732,98 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_startvalue,&__pyx_n_s_offsetonreverse,&__pyx_n_s_accelerationinitlong,&__pyx_n_s_accelerationlong,&__pyx_n_s_accelerationmaxlong,&__pyx_n_s_accelerationinitshort,&__pyx_n_s_accelerationshort,&__pyx_n_s_accelerationmaxshort,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("SAREXT", 0, 2, 10, 1); __PYX_ERR(3, 4418, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_startvalue); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_offsetonreverse); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationinitlong); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationlong); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 6: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationmaxlong); - if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 7: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationinitshort); - if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 8: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationshort); - if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 9: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationmaxshort); - if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4418, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "SAREXT") < 0)) __PYX_ERR(3, 4418, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4520, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4520, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -43492,82 +34831,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_startvalue = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_startvalue == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4420, __pyx_L3_error) + __pyx_v_startvalue = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_startvalue == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error) } else { __pyx_v_startvalue = ((double)((double)-4e37)); } if (values[3]) { - __pyx_v_offsetonreverse = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_offsetonreverse == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4420, __pyx_L3_error) + __pyx_v_offsetonreverse = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_offsetonreverse == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error) } else { __pyx_v_offsetonreverse = ((double)((double)-4e37)); } if (values[4]) { - __pyx_v_accelerationinitlong = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_accelerationinitlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4420, __pyx_L3_error) + __pyx_v_accelerationinitlong = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_accelerationinitlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error) } else { __pyx_v_accelerationinitlong = ((double)((double)-4e37)); } if (values[5]) { - __pyx_v_accelerationlong = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_accelerationlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4420, __pyx_L3_error) + __pyx_v_accelerationlong = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_accelerationlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error) } else { __pyx_v_accelerationlong = ((double)((double)-4e37)); } if (values[6]) { - __pyx_v_accelerationmaxlong = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_accelerationmaxlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4420, __pyx_L3_error) + __pyx_v_accelerationmaxlong = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_accelerationmaxlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error) } else { __pyx_v_accelerationmaxlong = ((double)((double)-4e37)); } if (values[7]) { - __pyx_v_accelerationinitshort = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_accelerationinitshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4420, __pyx_L3_error) + __pyx_v_accelerationinitshort = __Pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_accelerationinitshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error) } else { __pyx_v_accelerationinitshort = ((double)((double)-4e37)); } if (values[8]) { - __pyx_v_accelerationshort = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_accelerationshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4420, __pyx_L3_error) + __pyx_v_accelerationshort = __Pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_accelerationshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error) } else { __pyx_v_accelerationshort = ((double)((double)-4e37)); } if (values[9]) { - __pyx_v_accelerationmaxshort = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_accelerationmaxshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4420, __pyx_L3_error) + __pyx_v_accelerationmaxshort = __Pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_accelerationmaxshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error) } else { __pyx_v_accelerationmaxshort = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("SAREXT", 0, 2, 10, __pyx_nargs); __PYX_ERR(3, 4418, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("SAREXT", 0, 2, 10, __pyx_nargs); __PYX_ERR(4, 4520, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4420, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4420, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_284SAREXT(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4522, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4522, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_290SAREXT(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort) { +static PyObject *__pyx_pf_5talib_7_ta_lib_290SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -43580,10 +34918,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -43591,39 +34926,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__py __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4446, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4548, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4447, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4549, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4448, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4449, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4449, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4449, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_SAREXT_Lookback(__pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4452, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4453, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4453, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4453, __pyx_L1_error) - __pyx_v_retCode = TA_SAREXT(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_SAREXT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SAREXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4454, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SAREXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -43649,16 +34979,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_287SIN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_293SIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_286SIN, " SIN(real)\n\n Vector Trigonometric Sin (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_287SIN = {"SIN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_287SIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_286SIN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_287SIN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -43678,7 +35008,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("SIN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -43686,71 +35016,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4559, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4457, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "SIN") < 0)) __PYX_ERR(3, 4457, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4559, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("SIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 4457, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("SIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4559, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.SIN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4459, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_286SIN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4561, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_292SIN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_286SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_292SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -43762,42 +35086,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_286SIN(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("SIN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4476, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4477, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4478, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4478, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4580, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_SIN_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4481, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4482, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4482, __pyx_L1_error) - __pyx_v_retCode = TA_SIN(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_SIN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4483, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -43822,16 +35139,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_286SIN(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_289SINH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_295SINH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_288SINH, " SINH(real)\n\n Vector Trigonometric Sinh (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_289SINH = {"SINH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_289SINH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_288SINH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_289SINH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -43851,7 +35168,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("SINH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -43859,71 +35176,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4588, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4486, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "SINH") < 0)) __PYX_ERR(3, 4486, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4588, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("SINH", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 4486, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("SINH", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4588, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.SINH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4488, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_288SINH(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4590, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_294SINH(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_288SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_294SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -43935,42 +35246,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_288SINH(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("SINH", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4505, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4607, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4506, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4507, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4507, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4609, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_SINH_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4510, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4511, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4511, __pyx_L1_error) - __pyx_v_retCode = TA_SINH(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_SINH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SINH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4512, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SINH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -43995,16 +35299,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_288SINH(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_291SMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_297SMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_290SMA, " SMA(real[, timeperiod=?])\n\n Simple Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_291SMA = {"SMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_291SMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_290SMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_291SMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -44025,7 +35329,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("SMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -44033,89 +35337,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4617, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4617, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4515, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4515, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "SMA") < 0)) __PYX_ERR(3, 4515, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4617, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4617, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4517, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4619, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("SMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4515, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("SMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4617, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.SMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4517, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_290SMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4619, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_296SMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_290SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_296SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -44127,42 +35423,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_290SMA(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("SMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4536, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4638, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4537, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4538, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4538, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4640, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_SMA_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4541, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4643, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4542, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4542, __pyx_L1_error) - __pyx_v_retCode = TA_SMA(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_SMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4543, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4645, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -44187,16 +35476,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_290SMA(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_293SQRT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_299SQRT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_292SQRT, " SQRT(real)\n\n Vector Square Root (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_293SQRT = {"SQRT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_293SQRT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_292SQRT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_293SQRT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -44216,7 +35505,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("SQRT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -44224,71 +35513,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4648, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4546, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "SQRT") < 0)) __PYX_ERR(3, 4546, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4648, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("SQRT", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 4546, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("SQRT", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4648, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.SQRT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4548, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_292SQRT(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4650, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_298SQRT(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_292SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_298SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -44300,42 +35583,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_292SQRT(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("SQRT", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4565, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4566, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4567, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4567, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4669, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_SQRT_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4570, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4571, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4571, __pyx_L1_error) - __pyx_v_retCode = TA_SQRT(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_SQRT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SQRT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4572, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SQRT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -44360,16 +35636,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_292SQRT(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_295STDDEV(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_301STDDEV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_294STDDEV, " STDDEV(real[, timeperiod=?, nbdev=?])\n\n Standard Deviation (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 5\n nbdev: 1.0\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_295STDDEV = {"STDDEV", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_295STDDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_294STDDEV}; -static PyObject *__pyx_pw_5talib_7_ta_lib_295STDDEV(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -44391,7 +35667,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("STDDEV (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -44399,105 +35675,94 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdev,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4677, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4575, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4575, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nbdev); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4575, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "STDDEV") < 0)) __PYX_ERR(3, 4575, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4677, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4577, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4679, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_nbdev = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4577, __pyx_L3_error) + __pyx_v_nbdev = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4679, __pyx_L3_error) } else { __pyx_v_nbdev = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("STDDEV", 0, 1, 3, __pyx_nargs); __PYX_ERR(3, 4575, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("STDDEV", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 4677, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4577, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_294STDDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4679, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_300STDDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_294STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) { +static PyObject *__pyx_pf_5talib_7_ta_lib_300STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -44509,42 +35774,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_294STDDEV(CYTHON_UNUSED PyObject *__py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("STDDEV", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4597, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4598, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4599, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4599, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4701, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_STDDEV_Lookback(__pyx_v_timeperiod, __pyx_v_nbdev)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4602, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4603, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4603, __pyx_L1_error) - __pyx_v_retCode = TA_STDDEV(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_STDDEV(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STDDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4604, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STDDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -44569,16 +35827,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_294STDDEV(CYTHON_UNUSED PyObject *__py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_297STOCH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_303STOCH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_296STOCH, " STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\n Stochastic (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n fastk_period: 5\n slowk_period: 3\n slowk_matype: 0\n slowd_period: 3\n slowd_matype: 0\n Outputs:\n slowk\n slowd\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_297STOCH = {"STOCH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_297STOCH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_296STOCH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_297STOCH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -44605,7 +35863,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("STOCH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -44613,113 +35871,80 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_fastk_period,&__pyx_n_s_slowk_period,&__pyx_n_s_slowk_matype,&__pyx_n_s_slowd_period,&__pyx_n_s_slowd_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4607, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4607, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, 1); __PYX_ERR(3, 4607, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4607, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, 2); __PYX_ERR(3, 4607, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastk_period); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4607, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowk_period); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4607, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowk_matype); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4607, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 6: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowd_period); - if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4607, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 7: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowd_matype); - if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4607, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "STOCH") < 0)) __PYX_ERR(3, 4607, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4709, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4709, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4709, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4709, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -44728,68 +35953,67 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4609, __pyx_L3_error) + __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error) } else { __pyx_v_fastk_period = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_slowk_period = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_slowk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4609, __pyx_L3_error) + __pyx_v_slowk_period = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_slowk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error) } else { __pyx_v_slowk_period = ((int)((int)-2147483648)); } if (values[5]) { - __pyx_v_slowk_matype = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_slowk_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4609, __pyx_L3_error) + __pyx_v_slowk_matype = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_slowk_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error) } else { __pyx_v_slowk_matype = ((int)((int)0)); } if (values[6]) { - __pyx_v_slowd_period = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_slowd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4609, __pyx_L3_error) + __pyx_v_slowd_period = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_slowd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error) } else { __pyx_v_slowd_period = ((int)((int)-2147483648)); } if (values[7]) { - __pyx_v_slowd_matype = __Pyx_PyInt_As_int(values[7]); if (unlikely((__pyx_v_slowd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4609, __pyx_L3_error) + __pyx_v_slowd_matype = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_slowd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error) } else { __pyx_v_slowd_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, __pyx_nargs); __PYX_ERR(3, 4607, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, __pyx_nargs); __PYX_ERR(4, 4709, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4609, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4609, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4609, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_296STOCH(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4711, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4711, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4711, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_302STOCH(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_296STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_302STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -44803,12 +36027,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_296STOCH(CYTHON_UNUSED PyObject *__pyx __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -44817,64 +36036,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_296STOCH(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4634, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4635, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4636, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4637, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4638, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4638, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4638, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4638, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_STOCH_Lookback(__pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4641, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outslowk = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4642, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outslowd = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4643, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4643, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4643, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outslowk); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4643, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outslowd); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4643, __pyx_L1_error) - __pyx_v_retCode = TA_STOCH(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback), (((double *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_STOCH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outslowk)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outslowd)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4644, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4645, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outslowk); __Pyx_GIVEREF((PyObject *)__pyx_v_outslowk); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outslowk))) __PYX_ERR(3, 4645, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outslowk)) != (0)) __PYX_ERR(4, 4747, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outslowd); __Pyx_GIVEREF((PyObject *)__pyx_v_outslowd); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outslowd))) __PYX_ERR(3, 4645, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outslowd)) != (0)) __PYX_ERR(4, 4747, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -44898,16 +36109,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_296STOCH(CYTHON_UNUSED PyObject *__pyx /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_299STOCHF(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_305STOCHF(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_298STOCHF, " STOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\n Stochastic Fast (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\n Outputs:\n fastk\n fastd\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_299STOCHF = {"STOCHF", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_299STOCHF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_298STOCHF}; -static PyObject *__pyx_pw_5talib_7_ta_lib_299STOCHF(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -44932,7 +36143,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("STOCHF (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -44940,91 +36151,64 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_fastk_period,&__pyx_n_s_fastd_period,&__pyx_n_s_fastd_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4749, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4647, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4647, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, 1); __PYX_ERR(3, 4647, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4647, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, 2); __PYX_ERR(3, 4647, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastk_period); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4647, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastd_period); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4647, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastd_matype); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4647, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "STOCHF") < 0)) __PYX_ERR(3, 4647, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4749, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4749, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4749, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -45033,58 +36217,57 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4649, __pyx_L3_error) + __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4751, __pyx_L3_error) } else { __pyx_v_fastk_period = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_fastd_period = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4649, __pyx_L3_error) + __pyx_v_fastd_period = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4751, __pyx_L3_error) } else { __pyx_v_fastd_period = ((int)((int)-2147483648)); } if (values[5]) { - __pyx_v_fastd_matype = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4649, __pyx_L3_error) + __pyx_v_fastd_matype = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4751, __pyx_L3_error) } else { __pyx_v_fastd_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, __pyx_nargs); __PYX_ERR(3, 4647, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, __pyx_nargs); __PYX_ERR(4, 4749, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4649, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4649, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4649, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_298STOCHF(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4751, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4751, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4751, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_304STOCHF(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_298STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_304STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -45098,12 +36281,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_298STOCHF(CYTHON_UNUSED PyObject *__py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; - char *__pyx_t_8; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -45112,64 +36290,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_298STOCHF(CYTHON_UNUSED PyObject *__py __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4672, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4774, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4673, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4775, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4674, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4675, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4676, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4676, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4676, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4676, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_STOCHF_Lookback(__pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4679, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outfastk = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4680, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outfastd = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4681, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4681, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4681, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastk); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4681, __pyx_L1_error) - __pyx_t_8 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastd); if (unlikely(__pyx_t_8 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4681, __pyx_L1_error) - __pyx_v_retCode = TA_STOCHF(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback), (((double *)__pyx_t_8) + __pyx_v_lookback)); + __pyx_v_retCode = TA_STOCHF(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastk)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastd)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCHF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4682, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCHF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4683, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outfastk); __Pyx_GIVEREF((PyObject *)__pyx_v_outfastk); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outfastk))) __PYX_ERR(3, 4683, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outfastk)) != (0)) __PYX_ERR(4, 4785, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outfastd); __Pyx_GIVEREF((PyObject *)__pyx_v_outfastd); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfastd))) __PYX_ERR(3, 4683, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfastd)) != (0)) __PYX_ERR(4, 4785, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -45193,16 +36363,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_298STOCHF(CYTHON_UNUSED PyObject *__py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_301STOCHRSI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_307STOCHRSI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_300STOCHRSI, " STOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\n Stochastic Relative Strength Index (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\n Outputs:\n fastk\n fastd\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_301STOCHRSI = {"STOCHRSI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_301STOCHRSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_300STOCHRSI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_301STOCHRSI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -45226,7 +36396,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("STOCHRSI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -45234,137 +36404,120 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_fastk_period,&__pyx_n_s_fastd_period,&__pyx_n_s_fastd_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4787, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4685, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4685, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastk_period); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4685, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastd_period); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4685, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastd_matype); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4685, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "STOCHRSI") < 0)) __PYX_ERR(3, 4685, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4787, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4687, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4789, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4687, __pyx_L3_error) + __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4789, __pyx_L3_error) } else { __pyx_v_fastk_period = ((int)((int)-2147483648)); } if (values[3]) { - __pyx_v_fastd_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4687, __pyx_L3_error) + __pyx_v_fastd_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4789, __pyx_L3_error) } else { __pyx_v_fastd_period = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_fastd_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4687, __pyx_L3_error) + __pyx_v_fastd_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4789, __pyx_L3_error) } else { __pyx_v_fastd_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("STOCHRSI", 0, 1, 5, __pyx_nargs); __PYX_ERR(3, 4685, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("STOCHRSI", 0, 1, 5, __pyx_nargs); __PYX_ERR(4, 4787, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4687, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_300STOCHRSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4789, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_306STOCHRSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_300STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_306STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -45377,61 +36530,52 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_300STOCHRSI(CYTHON_UNUSED PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("STOCHRSI", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4711, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4712, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4713, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4713, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4815, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_STOCHRSI_Lookback(__pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4716, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outfastk = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4717, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outfastd = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4718, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastk); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4718, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastd); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4718, __pyx_L1_error) - __pyx_v_retCode = TA_STOCHRSI(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_STOCHRSI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastk)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastd)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCHRSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4719, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCHRSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4821, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4720, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_outfastk); __Pyx_GIVEREF((PyObject *)__pyx_v_outfastk); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outfastk))) __PYX_ERR(3, 4720, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outfastk)) != (0)) __PYX_ERR(4, 4822, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_outfastd); __Pyx_GIVEREF((PyObject *)__pyx_v_outfastd); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfastd))) __PYX_ERR(3, 4720, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfastd)) != (0)) __PYX_ERR(4, 4822, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -45453,16 +36597,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_300STOCHRSI(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_303SUB(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_309SUB(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_302SUB, " SUB(real0, real1)\n\n Vector Arithmetic Subtraction (Math Operators)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_303SUB = {"SUB", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_303SUB, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_302SUB}; -static PyObject *__pyx_pw_5talib_7_ta_lib_303SUB(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -45483,7 +36627,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("SUB (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -45491,86 +36635,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4824, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4824, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4722, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4722, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("SUB", 1, 2, 2, 1); __PYX_ERR(3, 4722, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "SUB") < 0)) __PYX_ERR(3, 4722, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4824, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4824, __pyx_L3_error) } __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("SUB", 1, 2, 2, __pyx_nargs); __PYX_ERR(3, 4722, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("SUB", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 4824, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.SUB", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 4724, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 4724, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_302SUB(__pyx_self, __pyx_v_real0, __pyx_v_real1); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 4826, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 4826, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_308SUB(__pyx_self, __pyx_v_real0, __pyx_v_real1); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { +static PyObject *__pyx_pf_5talib_7_ta_lib_308SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -45583,10 +36714,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_s __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - npy_int __pyx_t_5; - char *__pyx_t_6; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -45594,39 +36722,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_s __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4742, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4844, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4743, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4744, __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_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4745, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4745, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4)); if (unlikely(__pyx_t_5 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4745, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_5; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_SUB_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4748, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4850, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4749, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4749, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_6 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4749, __pyx_L1_error) - __pyx_v_retCode = TA_SUB(0, __pyx_v_endidx, (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_6) + __pyx_v_lookback)); + __pyx_v_retCode = TA_SUB(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SUB, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4750, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SUB, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -45652,16 +36775,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_305SUM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_311SUM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_304SUM, " SUM(real[, timeperiod=?])\n\n Summation (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_305SUM = {"SUM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_305SUM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_304SUM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_305SUM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -45682,7 +36805,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("SUM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -45690,89 +36813,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4855, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4855, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4753, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4753, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "SUM") < 0)) __PYX_ERR(3, 4753, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4855, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4855, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4755, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4857, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("SUM", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4753, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("SUM", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4855, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.SUM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4755, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_304SUM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4857, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_310SUM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_304SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_310SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -45784,42 +36899,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_304SUM(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("SUM", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4774, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4775, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4776, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4776, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4878, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_SUM_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4779, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4780, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4780, __pyx_L1_error) - __pyx_v_retCode = TA_SUM(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_SUM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SUM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4781, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SUM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -45844,16 +36952,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_304SUM(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_307T3(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_313T3(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_306T3, " T3(real[, timeperiod=?, vfactor=?])\n\n Triple Exponential Moving Average (T3) (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 5\n vfactor: 0.7\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_307T3 = {"T3", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_307T3, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_306T3}; -static PyObject *__pyx_pw_5talib_7_ta_lib_307T3(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -45875,7 +36983,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("T3 (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -45883,105 +36991,94 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_vfactor,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4886, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4886, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4886, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4784, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4784, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vfactor); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4784, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "T3") < 0)) __PYX_ERR(3, 4784, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4886, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4886, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4886, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4786, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4888, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_vfactor = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vfactor == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4786, __pyx_L3_error) + __pyx_v_vfactor = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vfactor == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4888, __pyx_L3_error) } else { __pyx_v_vfactor = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("T3", 0, 1, 3, __pyx_nargs); __PYX_ERR(3, 4784, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("T3", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 4886, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.T3", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4786, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_306T3(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_vfactor); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4888, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_312T3(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_vfactor); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_306T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor) { +static PyObject *__pyx_pf_5talib_7_ta_lib_312T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -45993,42 +37090,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_306T3(CYTHON_UNUSED PyObject *__pyx_se PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("T3", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4806, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4908, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4807, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4808, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4808, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4910, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_T3_Lookback(__pyx_v_timeperiod, __pyx_v_vfactor)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4811, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4812, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4812, __pyx_L1_error) - __pyx_v_retCode = TA_T3(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_vfactor, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_T3(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_vfactor, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_T3, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4813, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_T3, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4915, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -46053,16 +37143,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_306T3(CYTHON_UNUSED PyObject *__pyx_se /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_309TAN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_315TAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_308TAN, " TAN(real)\n\n Vector Trigonometric Tan (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_309TAN = {"TAN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_309TAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_308TAN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_309TAN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -46082,7 +37172,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("TAN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -46090,71 +37180,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4918, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4816, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "TAN") < 0)) __PYX_ERR(3, 4816, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4918, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("TAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 4816, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("TAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4918, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.TAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4818, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_308TAN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4920, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_314TAN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_308TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_314TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -46166,42 +37250,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_308TAN(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("TAN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4835, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4937, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4836, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4837, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4837, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4939, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_TAN_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4840, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4942, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4841, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4841, __pyx_L1_error) - __pyx_v_retCode = TA_TAN(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_TAN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4842, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4944, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -46226,16 +37303,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_308TAN(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_311TANH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_317TANH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_310TANH, " TANH(real)\n\n Vector Trigonometric Tanh (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_311TANH = {"TANH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_311TANH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_310TANH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_311TANH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -46255,7 +37332,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("TANH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -46263,71 +37340,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4947, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4845, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "TANH") < 0)) __PYX_ERR(3, 4845, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4947, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("TANH", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 4845, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("TANH", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4947, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.TANH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4847, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_310TANH(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4949, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_316TANH(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_310TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_316TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -46339,42 +37410,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_310TANH(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("TANH", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4864, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4966, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4865, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4866, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4866, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4968, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_TANH_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4869, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4870, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4870, __pyx_L1_error) - __pyx_v_retCode = TA_TANH(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_TANH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TANH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4871, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TANH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -46399,16 +37463,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_310TANH(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_313TEMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_319TEMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_312TEMA, " TEMA(real[, timeperiod=?])\n\n Triple Exponential Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_313TEMA = {"TEMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_313TEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_312TEMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_313TEMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -46429,7 +37493,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("TEMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -46437,89 +37501,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4976, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4976, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4874, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4874, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "TEMA") < 0)) __PYX_ERR(3, 4874, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4976, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4976, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4876, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4978, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("TEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4874, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("TEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4976, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4876, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_312TEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4978, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_318TEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_312TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_318TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -46531,42 +37587,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_312TEMA(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("TEMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4895, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4896, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4897, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4897, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4999, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_TEMA_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4900, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5002, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4901, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4901, __pyx_L1_error) - __pyx_v_retCode = TA_TEMA(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_TEMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4902, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5004, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -46591,16 +37640,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_312TEMA(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_315TRANGE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_321TRANGE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_314TRANGE, " TRANGE(high, low, close)\n\n True Range (Volatility Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_315TRANGE = {"TRANGE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_315TRANGE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_314TRANGE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_315TRANGE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -46622,7 +37671,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("TRANGE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -46630,59 +37679,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5007, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5007, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5007, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4905, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4905, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, 1); __PYX_ERR(3, 4905, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4905, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, 2); __PYX_ERR(3, 4905, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "TRANGE") < 0)) __PYX_ERR(3, 4905, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5007, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5007, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5007, __pyx_L3_error) } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); @@ -46690,41 +37720,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, __pyx_nargs); __PYX_ERR(3, 4905, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, __pyx_nargs); __PYX_ERR(4, 5007, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4907, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4907, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4907, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_314TRANGE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5009, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5009, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5009, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_320TRANGE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_320TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -46737,11 +37766,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -46750,46 +37775,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__py __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4924, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5026, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4925, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5027, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4926, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5028, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 4927, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4928, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4928, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4928, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4928, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_TRANGE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4931, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5033, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4932, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4932, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4932, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4932, __pyx_L1_error) - __pyx_v_retCode = TA_TRANGE(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_TRANGE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRANGE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4933, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRANGE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5035, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -46816,16 +37834,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_317TRIMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_323TRIMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_316TRIMA, " TRIMA(real[, timeperiod=?])\n\n Triangular Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_317TRIMA = {"TRIMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_317TRIMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_316TRIMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_317TRIMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -46846,7 +37864,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("TRIMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -46854,89 +37872,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5038, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5038, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4936, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4936, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "TRIMA") < 0)) __PYX_ERR(3, 4936, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5038, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5038, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4938, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5040, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("TRIMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4936, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("TRIMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5038, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4938, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_316TRIMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5040, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_322TRIMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_316TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_322TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -46948,42 +37958,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_316TRIMA(CYTHON_UNUSED PyObject *__pyx PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("TRIMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4957, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5059, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4958, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4959, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4959, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5061, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_TRIMA_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4962, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4963, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4963, __pyx_L1_error) - __pyx_v_retCode = TA_TRIMA(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_TRIMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRIMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4964, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRIMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5066, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -47008,16 +38011,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_316TRIMA(CYTHON_UNUSED PyObject *__pyx /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_319TRIX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_325TRIX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_318TRIX, " TRIX(real[, timeperiod=?])\n\n 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_319TRIX = {"TRIX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_319TRIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_318TRIX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_319TRIX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -47038,7 +38041,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("TRIX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -47046,89 +38049,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5069, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5069, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4967, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4967, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "TRIX") < 0)) __PYX_ERR(3, 4967, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5069, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5069, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4969, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5071, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("TRIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4967, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("TRIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5069, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4969, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_318TRIX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5071, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_324TRIX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_318TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_324TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -47140,42 +38135,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_318TRIX(CYTHON_UNUSED PyObject *__pyx_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("TRIX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4988, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5090, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4989, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4990, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4990, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5092, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_TRIX_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4993, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5095, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4994, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 4994, __pyx_L1_error) - __pyx_v_retCode = TA_TRIX(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_TRIX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4995, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -47200,16 +38188,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_318TRIX(CYTHON_UNUSED PyObject *__pyx_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_321TSF(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_327TSF(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_320TSF, " TSF(real[, timeperiod=?])\n\n Time Series Forecast (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_321TSF = {"TSF", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_321TSF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_320TSF}; -static PyObject *__pyx_pw_5talib_7_ta_lib_321TSF(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -47230,7 +38218,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("TSF (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -47238,89 +38226,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5100, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5100, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4998, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 4998, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "TSF") < 0)) __PYX_ERR(3, 4998, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5100, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5100, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5000, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5102, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("TSF", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 4998, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("TSF", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5100, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.TSF", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 5000, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_320TSF(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5102, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_326TSF(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_320TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_326TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -47332,42 +38312,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_320TSF(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("TSF", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5019, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5020, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5021, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5021, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5123, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_TSF_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5024, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5025, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5025, __pyx_L1_error) - __pyx_v_retCode = TA_TSF(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_TSF(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TSF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5026, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TSF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -47392,16 +38365,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_320TSF(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_323TYPPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_329TYPPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_322TYPPRICE, " TYPPRICE(high, low, close)\n\n Typical Price (Price Transform)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_323TYPPRICE = {"TYPPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_323TYPPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_322TYPPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_323TYPPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -47423,7 +38396,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("TYPPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -47431,59 +38404,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5131, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5131, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5131, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5029, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5029, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, 1); __PYX_ERR(3, 5029, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5029, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, 2); __PYX_ERR(3, 5029, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "TYPPRICE") < 0)) __PYX_ERR(3, 5029, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5131, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5131, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5131, __pyx_L3_error) } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); @@ -47491,41 +38445,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(3, 5029, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(4, 5131, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 5031, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 5031, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 5031, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_322TYPPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5133, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5133, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5133, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_328TYPPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_328TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -47538,11 +38491,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -47551,46 +38500,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5048, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5150, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5049, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5050, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 5051, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5052, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5052, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5052, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5052, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_TYPPRICE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5055, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5056, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5056, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5056, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5056, __pyx_L1_error) - __pyx_v_retCode = TA_TYPPRICE(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_TYPPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TYPPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5057, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TYPPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -47617,16 +38559,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_325ULTOSC(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_331ULTOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_324ULTOSC, " ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\n Ultimate Oscillator (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod1: 7\n timeperiod2: 14\n timeperiod3: 28\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_325ULTOSC = {"ULTOSC", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_325ULTOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_324ULTOSC}; -static PyObject *__pyx_pw_5talib_7_ta_lib_325ULTOSC(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -47651,7 +38593,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ULTOSC (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -47659,91 +38601,64 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod1,&__pyx_n_s_timeperiod2,&__pyx_n_s_timeperiod3,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 5162, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 5162, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 5162, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5162, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5162, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5162, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5060, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5060, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, 1); __PYX_ERR(3, 5060, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5060, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, 2); __PYX_ERR(3, 5060, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod1); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5060, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod2); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5060, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod3); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5060, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ULTOSC") < 0)) __PYX_ERR(3, 5060, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 5162, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 5162, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 5162, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5162, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5162, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5162, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -47752,58 +38667,57 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod1 = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5062, __pyx_L3_error) + __pyx_v_timeperiod1 = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5164, __pyx_L3_error) } else { __pyx_v_timeperiod1 = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_timeperiod2 = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_timeperiod2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5062, __pyx_L3_error) + __pyx_v_timeperiod2 = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_timeperiod2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5164, __pyx_L3_error) } else { __pyx_v_timeperiod2 = ((int)((int)-2147483648)); } if (values[5]) { - __pyx_v_timeperiod3 = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_timeperiod3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5062, __pyx_L3_error) + __pyx_v_timeperiod3 = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_timeperiod3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5164, __pyx_L3_error) } else { __pyx_v_timeperiod3 = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, __pyx_nargs); __PYX_ERR(3, 5060, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, __pyx_nargs); __PYX_ERR(4, 5162, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 5062, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 5062, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 5062, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_324ULTOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5164, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5164, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5164, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_330ULTOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_324ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3) { +static PyObject *__pyx_pf_5talib_7_ta_lib_330ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -47816,11 +38730,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_324ULTOSC(CYTHON_UNUSED PyObject *__py __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -47829,46 +38739,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_324ULTOSC(CYTHON_UNUSED PyObject *__py __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5083, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5185, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5084, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5085, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5187, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 5086, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5087, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5087, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5087, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5087, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_ULTOSC_Lookback(__pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5090, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5192, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5091, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5091, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5091, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5091, __pyx_L1_error) - __pyx_v_retCode = TA_ULTOSC(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_ULTOSC(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ULTOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5092, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ULTOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5194, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -47895,16 +38798,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_324ULTOSC(CYTHON_UNUSED PyObject *__py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_327VAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_333VAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_326VAR, " VAR(real[, timeperiod=?, nbdev=?])\n\n Variance (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 5\n nbdev: 1.0\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_327VAR = {"VAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_327VAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_326VAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_327VAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -47926,7 +38829,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("VAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -47934,105 +38837,94 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdev,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5197, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5197, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5197, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5095, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5095, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nbdev); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5095, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "VAR") < 0)) __PYX_ERR(3, 5095, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5197, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5197, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5197, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5097, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5199, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_nbdev = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 5097, __pyx_L3_error) + __pyx_v_nbdev = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 5199, __pyx_L3_error) } else { __pyx_v_nbdev = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("VAR", 0, 1, 3, __pyx_nargs); __PYX_ERR(3, 5095, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("VAR", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 5197, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.VAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 5097, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_326VAR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5199, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_332VAR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_326VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) { +static PyObject *__pyx_pf_5talib_7_ta_lib_332VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -48044,42 +38936,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_326VAR(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("VAR", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5117, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5219, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5118, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5119, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5119, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5221, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_VAR_Lookback(__pyx_v_timeperiod, __pyx_v_nbdev)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5122, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5123, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5123, __pyx_L1_error) - __pyx_v_retCode = TA_VAR(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_VAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_VAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5124, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_VAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -48104,16 +38989,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_326VAR(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_329WCLPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_335WCLPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_328WCLPRICE, " WCLPRICE(high, low, close)\n\n Weighted Close Price (Price Transform)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_329WCLPRICE = {"WCLPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_329WCLPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_328WCLPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_329WCLPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -48135,7 +39020,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("WCLPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -48143,59 +39028,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5229, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5229, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5229, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5127, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5127, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, 1); __PYX_ERR(3, 5127, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5127, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, 2); __PYX_ERR(3, 5127, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "WCLPRICE") < 0)) __PYX_ERR(3, 5127, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5229, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5229, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5229, __pyx_L3_error) } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); @@ -48203,41 +39069,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(3, 5127, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(4, 5229, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 5129, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 5129, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 5129, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_328WCLPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5231, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5231, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5231, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_334WCLPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_328WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_334WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -48250,11 +39115,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_328WCLPRICE(CYTHON_UNUSED PyObject *__ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -48263,46 +39124,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_328WCLPRICE(CYTHON_UNUSED PyObject *__ __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5146, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5147, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5148, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 5149, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5150, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5150, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5150, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5150, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_WCLPRICE_Lookback()); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5153, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5154, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5154, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5154, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5154, __pyx_L1_error) - __pyx_v_retCode = TA_WCLPRICE(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_WCLPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WCLPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5155, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WCLPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -48329,16 +39183,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_328WCLPRICE(CYTHON_UNUSED PyObject *__ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_331WILLR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_337WILLR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_330WILLR, " WILLR(high, low, close[, timeperiod=?])\n\n Williams' %R (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_331WILLR = {"WILLR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_331WILLR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_330WILLR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_331WILLR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -48361,7 +39215,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("WILLR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -48369,69 +39223,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 5260, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5260, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5260, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5260, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5158, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5158, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, 1); __PYX_ERR(3, 5158, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5158, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, 2); __PYX_ERR(3, 5158, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5158, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "WILLR") < 0)) __PYX_ERR(3, 5158, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 5260, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5260, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5260, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5260, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -48440,48 +39273,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5160, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5262, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, __pyx_nargs); __PYX_ERR(3, 5158, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 5260, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 5160, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 5160, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 5160, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_330WILLR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5262, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5262, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5262, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_336WILLR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_336WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -48494,11 +39326,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; npy_intp __pyx_t_2; - char *__pyx_t_3; - char *__pyx_t_4; - char *__pyx_t_5; - npy_int __pyx_t_6; - char *__pyx_t_7; + npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -48507,46 +39335,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5179, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5180, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5181, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5283, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(3, 5182, __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_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5183, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5183, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5183, __pyx_L1_error) - __pyx_t_6 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_t_3), ((double *)__pyx_t_4), ((double *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5183, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_6; + __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) + __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_WILLR_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5186, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5187, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_4 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5187, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5187, __pyx_L1_error) - __pyx_t_7 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_7 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5187, __pyx_L1_error) - __pyx_v_retCode = TA_WILLR(0, __pyx_v_endidx, (((double *)__pyx_t_5) + __pyx_v_begidx), (((double *)__pyx_t_4) + __pyx_v_begidx), (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_7) + __pyx_v_lookback)); + __pyx_v_retCode = TA_WILLR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WILLR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5188, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WILLR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -48573,16 +39394,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_333WMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_339WMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_332WMA, " WMA(real[, timeperiod=?])\n\n Weighted Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_333WMA = {"WMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_333WMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_332WMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_333WMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -48603,7 +39424,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("WMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -48611,89 +39432,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5293, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5293, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5191, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5191, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "WMA") < 0)) __PYX_ERR(3, 5191, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5293, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5293, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5193, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5295, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("WMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(3, 5191, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("WMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5293, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.WMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 5193, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_332WMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5295, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_338WMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_332WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_338WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; int __pyx_v_begidx; int __pyx_v_endidx; @@ -48705,42 +39518,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_332WMA(CYTHON_UNUSED PyObject *__pyx_s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - npy_intp *__pyx_t_2; - char *__pyx_t_3; - npy_int __pyx_t_4; - char *__pyx_t_5; + npy_int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("WMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5212, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_2 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5213, __pyx_L1_error) - __pyx_v_length = (__pyx_t_2[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5214, __pyx_L1_error) - __pyx_t_4 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_t_3)); if (unlikely(__pyx_t_4 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5214, __pyx_L1_error) - __pyx_v_begidx = __pyx_t_4; + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5316, __pyx_L1_error) + __pyx_v_begidx = __pyx_t_2; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __pyx_v_lookback = (__pyx_v_begidx + TA_WMA_Lookback(__pyx_v_timeperiod)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5217, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5218, __pyx_L1_error) - __pyx_t_5 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal); if (unlikely(__pyx_t_5 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(3, 5218, __pyx_L1_error) - __pyx_v_retCode = TA_WMA(0, __pyx_v_endidx, (((double *)__pyx_t_3) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_t_5) + __pyx_v_lookback)); + __pyx_v_retCode = TA_WMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5219, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -48765,15 +39571,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_332WMA(CYTHON_UNUSED PyObject *__pyx_s /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_335str2bytes(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_341str2bytes(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_335str2bytes = {"str2bytes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_335str2bytes, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_5talib_7_ta_lib_335str2bytes(PyObject *__pyx_self, +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_340str2bytes, "str2bytes(s)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_341str2bytes = {"str2bytes", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_341str2bytes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_340str2bytes}; +static PyObject *__pyx_pw_5talib_7_ta_lib_341str2bytes(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -48793,7 +39600,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("str2bytes (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -48801,89 +39608,77 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_s,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 74, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_s)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 57, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "str2bytes") < 0)) __PYX_ERR(1, 57, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 74, __pyx_L3_error) } __pyx_v_s = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 57, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 74, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_334str2bytes(__pyx_self, __pyx_v_s); + __pyx_r = __pyx_pf_5talib_7_ta_lib_340str2bytes(__pyx_self, __pyx_v_s); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_334str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s) { +static PyObject *__pyx_pf_5talib_7_ta_lib_340str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; + size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("str2bytes", 1); + __Pyx_RefNannySetupContext("str2bytes", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_s); - __Pyx_GIVEREF(__pyx_v_s); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_s)) __PYX_ERR(1, 58, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ascii); - __Pyx_GIVEREF(__pyx_n_s_ascii); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_ascii)) __PYX_ERR(1, 58, __pyx_L1_error); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyBytes_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __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((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; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; @@ -48901,15 +39696,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_334str2bytes(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_337bytes2str(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_343bytes2str(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_337bytes2str = {"bytes2str", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_337bytes2str, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_5talib_7_ta_lib_337bytes2str(PyObject *__pyx_self, +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_342bytes2str, "bytes2str(b)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_343bytes2str = {"bytes2str", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_343bytes2str, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_342bytes2str}; +static PyObject *__pyx_pw_5talib_7_ta_lib_343bytes2str(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -48929,7 +39725,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("bytes2str (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -48937,101 +39733,75 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 77, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_b)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 60, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "bytes2str") < 0)) __PYX_ERR(1, 60, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 77, __pyx_L3_error) } __pyx_v_b = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 60, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 77, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_336bytes2str(__pyx_self, __pyx_v_b); + __pyx_r = __pyx_pf_5talib_7_ta_lib_342bytes2str(__pyx_self, __pyx_v_b); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_336bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b) { +static PyObject *__pyx_pf_5talib_7_ta_lib_342bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; + size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("bytes2str", 1); + __Pyx_RefNannySetupContext("bytes2str", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_decode); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_2 = __pyx_v_b; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_n_s_ascii}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 61, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ascii}; + __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); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -49042,7 +39812,6 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_336bytes2str(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.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -49053,15 +39822,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_336bytes2str(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_339str2bytes(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_345str2bytes(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_339str2bytes = {"str2bytes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_339str2bytes, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_5talib_7_ta_lib_339str2bytes(PyObject *__pyx_self, +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_344str2bytes, "str2bytes(s)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_345str2bytes = {"str2bytes", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_345str2bytes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_344str2bytes}; +static PyObject *__pyx_pw_5talib_7_ta_lib_345str2bytes(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -49081,7 +39851,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("str2bytes (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -49089,69 +39859,58 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_s,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 82, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_s)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 65, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "str2bytes") < 0)) __PYX_ERR(1, 65, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 82, __pyx_L3_error) } __pyx_v_s = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 65, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 82, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_338str2bytes(__pyx_self, __pyx_v_s); + __pyx_r = __pyx_pf_5talib_7_ta_lib_344str2bytes(__pyx_self, __pyx_v_s); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_338str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s) { +static PyObject *__pyx_pf_5talib_7_ta_lib_344str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("str2bytes", 1); + __Pyx_RefNannySetupContext("str2bytes", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_s); @@ -49168,15 +39927,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_338str2bytes(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_341bytes2str(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_347bytes2str(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_341bytes2str = {"bytes2str", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_341bytes2str, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_5talib_7_ta_lib_341bytes2str(PyObject *__pyx_self, +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_346bytes2str, "bytes2str(b)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_347bytes2str = {"bytes2str", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_347bytes2str, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_346bytes2str}; +static PyObject *__pyx_pw_5talib_7_ta_lib_347bytes2str(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -49196,7 +39956,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("bytes2str (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -49204,69 +39964,58 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 85, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_b)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 68, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "bytes2str") < 0)) __PYX_ERR(1, 68, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 85, __pyx_L3_error) } __pyx_v_b = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 68, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 85, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_340bytes2str(__pyx_self, __pyx_v_b); + __pyx_r = __pyx_pf_5talib_7_ta_lib_346bytes2str(__pyx_self, __pyx_v_b); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_340bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b) { +static PyObject *__pyx_pf_5talib_7_ta_lib_346bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("bytes2str", 1); + __Pyx_RefNannySetupContext("bytes2str", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_b); @@ -49290,7 +40039,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_1__init__ = {"__init__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function___init__, "Function.__init__(self, function_name, func_object, *args, **kwargs)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function___init__}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_1__init__(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -49315,7 +40065,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -49332,60 +40082,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } __Pyx_GOTREF(__pyx_v_args); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_function_name,&__pyx_n_s_func_object,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { default: - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 117, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 0: break; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 100, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 117, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_function_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 100, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, 1); __PYX_ERR(1, 100, __pyx_L3_error) - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 117, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_func_object)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 100, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, 2); __PYX_ERR(1, 100, __pyx_L3_error) - } + case 0: break; } - if (unlikely(kw_args > 0)) { - 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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values + 0, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 100, __pyx_L3_error) + 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) + 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) } } } else if (unlikely(__pyx_nargs < 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 117, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 117, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 117, __pyx_L3_error) } __pyx_v_self = values[0]; __pyx_v_function_name = values[1]; @@ -49393,15 +40124,12 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, __pyx_nargs); __PYX_ERR(1, 100, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, __pyx_nargs); __PYX_ERR(2, 117, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; @@ -49412,14 +40140,11 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function___init__(__pyx_self, __pyx_v_self, __pyx_v_function_name, __pyx_v_func_object, __pyx_v_args, __pyx_v_kwargs); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_DECREF(__pyx_v_args); __Pyx_DECREF(__pyx_v_kwargs); - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -49429,117 +40154,101 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObj __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; + size_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 1); + __Pyx_RefNannySetupContext("__init__", 0); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_function_name, __pyx_n_s_upper); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_2 = __pyx_v_function_name; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 102, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __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); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__name, __pyx_t_1) < 0) __PYX_ERR(1, 102, __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_n_s_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 103, __pyx_L1_error) + __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_n_s_Function__namestr, __pyx_t_1) < 0) __PYX_ERR(1, 103, __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_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str2bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = NULL; - __pyx_t_4 = 0; + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_str2bytes); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __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, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_3 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 104, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5}; + __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); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__name, __pyx_t_1) < 0) __PYX_ERR(1, 104, __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_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_threading); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 107, __pyx_L1_error) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_local); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_local); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_3 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_4 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_3 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 107, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __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); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__localdata, __pyx_t_1) < 0) __PYX_ERR(1, 107, __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_n_s_set_function_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 110, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 110, __pyx_L1_error) + __pyx_t_2 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __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_n_s_func_object, __pyx_v_func_object) < 0) __PYX_ERR(1, 111, __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 */ @@ -49548,7 +40257,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObj __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("talib._ta_lib.Function.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; @@ -49567,7 +40276,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_3__local = {"__local", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_3__local, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_2__local, "Function.__local(self)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_3__local = {"__local", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_3__local, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_2__local}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_3__local(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -49588,7 +40298,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__local (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -49596,47 +40306,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 130, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 113, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__local") < 0)) __PYX_ERR(1, 113, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 130, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__local", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 113, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__local", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 130, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.__local", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -49645,11 +40347,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_2__local(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -49669,612 +40368,474 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + size_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; - Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_8 = NULL; PyObject *(*__pyx_t_9)(PyObject *); - PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__local", 1); + __Pyx_RefNannySetupContext("__local", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__localdata); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 115, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__localdata); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 132, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_2 = __Pyx_HasAttr(__pyx_v_local, __pyx_n_s_info); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 116, __pyx_L1_error) + __pyx_t_2 = __Pyx_HasAttr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(2, 133, __pyx_L1_error) __pyx_t_3 = (!__pyx_t_2); if (__pyx_t_3) { - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_n_s_info, Py_None) < 0) __PYX_ERR(1, 117, __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(1, 118, __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_n_s_input_arrays, __pyx_t_1) < 0) __PYX_ERR(1, 118, __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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - __pyx_t_6 = 0; + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 138, __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); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 121, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __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); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_n_s_input_names, __pyx_t_1) < 0) __PYX_ERR(1, 121, __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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; - __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __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; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); __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_n_s_opt_inputs, __pyx_t_1) < 0) __PYX_ERR(1, 122, __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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 123, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - __pyx_t_6 = 0; + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 140, __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); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 123, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __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); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_n_s_outputs, __pyx_t_1) < 0) __PYX_ERR(1, 123, __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_n_s_outputs_valid, Py_False) < 0) __PYX_ERR(1, 124, __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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ta_getFuncInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 127, __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) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = NULL; - __pyx_t_6 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } + __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); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __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_n_s_info, __pyx_t_1) < 0) __PYX_ERR(1, 127, __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 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_pop); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; + __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; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } + { + 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); } - #endif + __pyx_t_6 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_n_s_num_inputs}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + 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; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 130, __pyx_L1_error) + __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); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_xrange, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __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; - if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { - __pyx_t_1 = __pyx_t_5; __Pyx_INCREF(__pyx_t_1); - __pyx_t_8 = 0; - __pyx_t_9 = NULL; - } else { - __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 130, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; for (;;) { - if (likely(!__pyx_t_9)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 130, __pyx_L1_error) - #endif - if (__pyx_t_8 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(1, 130, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 130, __pyx_L1_error) - #endif - if (__pyx_t_8 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(1, 130, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } - } else { - __pyx_t_5 = __pyx_t_9(__pyx_t_1); - if (unlikely(!__pyx_t_5)) { + { + __pyx_t_1 = __pyx_t_9(__pyx_t_7); + if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 130, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 147, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_5); } - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5); - __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ta_getInputParameterInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = NULL; - __pyx_t_6 = 0; + __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_10 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } + 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_8, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_7, __pyx_v_i}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __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); } - __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_5); - __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_1); + __pyx_t_1 = 0; - __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_5); - __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1); + __pyx_t_1 = 0; - __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_price_series); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = (__pyx_t_5 == Py_None); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_t_1 == Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_3) { - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_v_input_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely((PyObject_SetItem(__pyx_v_info, __pyx_n_s_price_series, __pyx_t_4) < 0))) __PYX_ERR(1, 134, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __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_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_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_n_s_input_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 135, __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(1, 135, __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_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_n_s_input_names, __pyx_t_1) < 0))) __PYX_ERR(1, 136, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_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 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 139, __pyx_L1_error) + __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_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_pop); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } - } - #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_n_s_num_opt_inputs}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 139, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_opt_inputs}; + __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_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_xrange, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { - __pyx_t_1 = __pyx_t_5; __Pyx_INCREF(__pyx_t_1); - __pyx_t_8 = 0; - __pyx_t_9 = NULL; - } else { - __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 139, __pyx_L1_error) + __pyx_t_6 = 1; + { + 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); } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __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_9)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 139, __pyx_L1_error) - #endif - if (__pyx_t_8 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(1, 139, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 139, __pyx_L1_error) - #endif - if (__pyx_t_8 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(1, 139, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } - } else { - __pyx_t_5 = __pyx_t_9(__pyx_t_1); - if (unlikely(!__pyx_t_5)) { + { + __pyx_t_7 = __pyx_t_9(__pyx_t_1); + if (unlikely(!__pyx_t_7)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 139, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 156, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_5); } - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5); - __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_7); + __pyx_t_7 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ta_getOptInputParameterInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 140, __pyx_L1_error) + __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_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = NULL; - __pyx_t_6 = 0; + __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_10 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } + __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); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_7, __pyx_v_i}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + 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); } - __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_5); - __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_7); + __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_5); - __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_7); + __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_v_param_name, __pyx_v_info) < 0))) __PYX_ERR(1, 142, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (unlikely((PyObject_SetItem(__pyx_t_7, __pyx_v_param_name, __pyx_v_info) < 0))) __PYX_ERR(2, 159, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_parameters); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 143, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_n_s_parameters, __pyx_t_1) < 0))) __PYX_ERR(1, 143, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (unlikely((PyObject_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_1) < 0))) __PYX_ERR(2, 160, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = NULL; - __pyx_t_6 = 0; + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 146, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; + __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) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_n_s_output_flags, __pyx_t_1) < 0))) __PYX_ERR(1, 146, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_output_flags, __pyx_t_1) < 0))) __PYX_ERR(2, 163, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_pop); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = NULL; + __pyx_t_4 = NULL; + __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; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } - } - #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_n_s_num_outputs}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + 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; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 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_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_xrange, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { - __pyx_t_1 = __pyx_t_4; __Pyx_INCREF(__pyx_t_1); - __pyx_t_8 = 0; - __pyx_t_9 = NULL; - } else { - __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 147, __pyx_L1_error) + __pyx_t_6 = 1; + { + 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_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 147, __pyx_L1_error) } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __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_9)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 147, __pyx_L1_error) - #endif - if (__pyx_t_8 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_4); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(1, 147, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 147, __pyx_L1_error) - #endif - if (__pyx_t_8 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_4); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(1, 147, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } - } else { - __pyx_t_4 = __pyx_t_9(__pyx_t_1); - if (unlikely(!__pyx_t_4)) { + { + __pyx_t_1 = __pyx_t_9(__pyx_t_7); + if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 147, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 164, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_4); } - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_4); - __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_ta_getOutputParameterInfo); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 148, __pyx_L1_error) + __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_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = NULL; - __pyx_t_6 = 0; + __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } + 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_8, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_7, __pyx_v_i}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + 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, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); } - __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_4); - __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_1); + __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_output_name, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_output_name, __pyx_t_1); + __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_flags); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 150, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 150, __pyx_L1_error) + __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_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_t_7 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_n_s_output_flags); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 150, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __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; - if (unlikely((PyObject_SetItem(__pyx_t_7, __pyx_v_output_name, __pyx_t_4) < 0))) __PYX_ERR(1, 150, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_outputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_v_output_name, Py_None) < 0))) __PYX_ERR(1, 151, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_output_name, Py_None) < 0))) __PYX_ERR(2, 168, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_output_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 152, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 169, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_n_s_output_names, __pyx_t_1) < 0))) __PYX_ERR(1, 152, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_output_names, __pyx_t_7) < 0))) __PYX_ERR(2, 169, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } @@ -50290,7 +40851,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("talib._ta_lib.Function.__local", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -50314,8 +40875,8 @@ PyObject *const *__pyx_args, 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, "\n Returns a copy of the function's info dict.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_5info = {"info", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -50336,7 +40897,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("info (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -50344,47 +40905,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 172, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 155, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "info") < 0)) __PYX_ERR(1, 155, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 172, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("info", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 155, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("info", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 172, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.info", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -50393,11 +40946,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_4info(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -50409,42 +40959,29 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_4info(CYTHON_UNUSED PyObject PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("info", 1); + __Pyx_RefNannySetupContext("info", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 160, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 177, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_2 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 160, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __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) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -50456,6 +40993,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_4info(CYTHON_UNUSED PyObject __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("talib._ta_lib.Function.info", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -50473,8 +41011,8 @@ PyObject *const *__pyx_args, 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, "\n Returns any function flags defined for this indicator function.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_7function_flags = {"function_flags", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -50495,7 +41033,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("function_flags (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -50503,47 +41041,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 179, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 162, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "function_flags") < 0)) __PYX_ERR(1, 162, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 179, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("function_flags", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 162, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("function_flags", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 179, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.function_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -50552,11 +41082,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_6function_flags(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -50570,15 +41097,15 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_6function_flags(CYTHON_UNUSE int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("function_flags", 1); + __Pyx_RefNannySetupContext("function_flags", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 167, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 167, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_s_function_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 167, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_function_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; @@ -50607,8 +41134,8 @@ PyObject *const *__pyx_args, 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, "\n Returns the flags for each output for this indicator function.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_9output_flags = {"output_flags", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -50629,7 +41156,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("output_flags (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -50637,47 +41164,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 186, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 169, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "output_flags") < 0)) __PYX_ERR(1, 169, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 186, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("output_flags", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 169, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("output_flags", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 186, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.output_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -50686,11 +41205,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_8output_flags(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -50702,45 +41218,32 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_8output_flags(CYTHON_UNUSED PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("output_flags", 1); + __Pyx_RefNannySetupContext("output_flags", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 174, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 174, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 191, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_s_output_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 174, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 174, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_output_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 191, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_4 = 1; - } - } - #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __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; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 174, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -50752,6 +41255,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_8output_flags(CYTHON_UNUSED __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("talib._ta_lib.Function.output_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -50769,8 +41273,8 @@ PyObject *const *__pyx_args, 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, "\n Returns the dict of input price series names that specifies which\n of the ndarrays in input_arrays will be used to calculate the function.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_11get_input_names = {"get_input_names", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -50791,7 +41295,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_input_names (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -50799,47 +41303,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 193, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 176, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_input_names") < 0)) __PYX_ERR(1, 176, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 193, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_input_names", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 176, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_input_names", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 193, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.get_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -50848,11 +41344,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -50867,117 +41360,113 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(CYTHON_UNU PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; + size_t __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_input_names", 1); + __Pyx_RefNannySetupContext("get_input_names", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 181, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 182, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 182, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __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) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_v_ret = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 183, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { - __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 183, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 183, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 200, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { if (likely(!__pyx_t_6)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { + if (likely(PyList_CheckExact(__pyx_t_3))) { { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 183, __pyx_L1_error) + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 200, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 183, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 183, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_5; } else { { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 183, __pyx_L1_error) + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 200, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 183, __pyx_L1_error) + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5)); #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 183, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5); #endif + ++__pyx_t_5; } + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 200, __pyx_L1_error) } else { - __pyx_t_1 = __pyx_t_6(__pyx_t_2); + __pyx_t_1 = __pyx_t_6(__pyx_t_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 183, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 200, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } + __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 184, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 184, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_s_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 184, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely((PyObject_SetItem(__pyx_v_ret, __pyx_v_input_name, __pyx_t_1) < 0))) __PYX_ERR(1, 184, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_ret, __pyx_v_input_name, __pyx_t_1) < 0))) __PYX_ERR(2, 201, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ret); @@ -51010,8 +41499,8 @@ PyObject *const *__pyx_args, 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, "\n Sets the input price series names to use.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_13set_input_names = {"set_input_names", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -51033,7 +41522,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_input_names (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -51041,61 +41530,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_names,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 204, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 204, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 187, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_input_names)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 187, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("set_input_names", 1, 2, 2, 1); __PYX_ERR(1, 187, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_input_names") < 0)) __PYX_ERR(1, 187, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 204, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 204, __pyx_L3_error) } __pyx_v_self = values[0]; __pyx_v_input_names = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("set_input_names", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 187, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set_input_names", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 204, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.set_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -51104,11 +41578,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(__pyx_self, __pyx_v_self, __pyx_v_input_names); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -51122,136 +41593,123 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNU __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - Py_ssize_t __pyx_t_5; - PyObject *(*__pyx_t_6)(PyObject *); + size_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *(*__pyx_t_5)(PyObject *); + PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *(*__pyx_t_9)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_input_names", 1); + __Pyx_RefNannySetupContext("set_input_names", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 191, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_names, __pyx_n_s_items); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_2 = __pyx_v_input_names; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 192, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __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); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); - __pyx_t_5 = 0; - __pyx_t_6 = NULL; + __pyx_t_4 = 0; + __pyx_t_5 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 192, __pyx_L1_error) + __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 192, __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, 209, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { - if (likely(!__pyx_t_6)) { + if (likely(!__pyx_t_5)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 192, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 209, __pyx_L1_error) #endif - if (__pyx_t_5 >= __pyx_temp) break; + if (__pyx_t_4 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 192, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif + __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_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 192, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 209, __pyx_L1_error) #endif - if (__pyx_t_5 >= __pyx_temp) break; + if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 192, __pyx_L1_error) + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4)); #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); #endif + ++__pyx_t_4; } + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 209, __pyx_L1_error) } else { - __pyx_t_1 = __pyx_t_6(__pyx_t_2); + __pyx_t_1 = __pyx_t_5(__pyx_t_2); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 192, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 209, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } + __Pyx_GOTREF(__pyx_t_1); if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 192, __pyx_L1_error) + __PYX_ERR(2, 209, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_7); } else { - __pyx_t_3 = PyList_GET_ITEM(sequence, 0); - __pyx_t_7 = PyList_GET_ITEM(sequence, 1); + __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_GetItemRefFast(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 209, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_7); } - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_7); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 192, __pyx_L1_error) + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; - __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 192, __pyx_L1_error) + __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); - index = 0; __pyx_t_3 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_3)) goto __pyx_L5_unpacking_failed; - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); + index = 0; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __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(1, 192, __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; @@ -51259,34 +41717,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNU __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_9 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(1, 192, __pyx_L1_error) + __PYX_ERR(2, 209, __pyx_L1_error) __pyx_L6_unpacking_done:; } - __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_6); + __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_price_series, __pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 193, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 193, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_7, __pyx_n_s_price_series, __pyx_v_price_series) < 0))) __PYX_ERR(1, 193, __pyx_L1_error) + if (unlikely((PyObject_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_v_price_series) < 0))) __PYX_ERR(2, 210, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 194, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_7, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 194, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_input_name, __pyx_v_price_series) < 0))) __PYX_ERR(1, 194, __pyx_L1_error) + if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_input_name, __pyx_v_price_series) < 0))) __PYX_ERR(2, 211, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_n_s_outputs_valid, Py_False) < 0) __PYX_ERR(1, 195, __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 */ @@ -51295,7 +41753,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNU __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("talib._ta_lib.Function.set_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -51318,8 +41776,8 @@ PyObject *const *__pyx_args, 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, "\n Returns a copy of the dict of input arrays in use.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_15get_input_arrays = {"get_input_arrays", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -51340,7 +41798,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_input_arrays (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -51348,47 +41806,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 216, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 199, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_input_arrays") < 0)) __PYX_ERR(1, 199, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 216, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_input_arrays", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 199, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_input_arrays", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 216, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.get_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -51397,11 +41847,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -51416,18 +41863,18 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UN int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + size_t __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_input_arrays", 1); + __Pyx_RefNannySetupContext("get_input_arrays", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 203, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 204, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = (__pyx_t_1 != Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -51437,11 +41884,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UN goto __pyx_L4_bool_binop_done; } - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 205, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_POLARS_DATAFRAME); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 205, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_IsInstance(__pyx_t_1, __pyx_t_4); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 205, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_t_1, __pyx_t_4); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 222, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __pyx_t_3; @@ -51450,32 +41897,18 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UN if (__pyx_t_2) { __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_clone); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 206, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; + __pyx_t_1 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_1); __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } - } - #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __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; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); } __pyx_r = __pyx_t_4; __pyx_t_4 = 0; @@ -51485,32 +41918,18 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UN /*else*/ { __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 208, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = NULL; + __pyx_t_5 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - __pyx_t_6 = 1; - } - } - #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __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; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); } __pyx_r = __pyx_t_4; __pyx_t_4 = 0; @@ -51541,8 +41960,8 @@ PyObject *const *__pyx_args, 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, "\n Sets the dict of input_arrays to use. Returns True/False for\n subclasses:\n\n If input_arrays is a dict with the keys open, high, low, close and\n volume, it is assigned as the input_array to use and this function\n returns True, returning False otherwise. If you implement your own\n data type and wish to subclass Function, you should wrap this function\n with an if-statement:\n\n class 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\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays = {"set_input_arrays", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -51564,7 +41983,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_input_arrays (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -51572,61 +41991,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_arrays,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 227, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 227, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 210, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_input_arrays)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 210, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("set_input_arrays", 1, 2, 2, 1); __PYX_ERR(1, 210, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_input_arrays") < 0)) __PYX_ERR(1, 210, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 227, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 227, __pyx_L3_error) } __pyx_v_self = values[0]; __pyx_v_input_arrays = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("set_input_arrays", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 210, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set_input_arrays", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 227, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.set_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -51635,11 +42039,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(__pyx_self, __pyx_v_self, __pyx_v_input_arrays); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -51655,137 +42056,123 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - Py_ssize_t __pyx_t_6; - PyObject *(*__pyx_t_7)(PyObject *); + size_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + int __pyx_t_7; int __pyx_t_8; - int __pyx_t_9; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11[4]; + PyObject *__pyx_t_12 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_input_arrays", 1); + __Pyx_RefNannySetupContext("set_input_arrays", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 236, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyObject_IsInstance(__pyx_v_input_arrays, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 236, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_v_input_arrays, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(2, 253, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 237, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_missing_keys = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_price_series_na); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __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); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); - __pyx_t_6 = 0; - __pyx_t_7 = NULL; + __pyx_t_5 = 0; + __pyx_t_6 = NULL; } else { - __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 238, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 238, __pyx_L1_error) + __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 255, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { - if (likely(!__pyx_t_7)) { + if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_3))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 238, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 255, __pyx_L1_error) #endif - if (__pyx_t_6 >= __pyx_temp) break; + if (__pyx_t_5 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 238, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_5; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 238, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 255, __pyx_L1_error) #endif - if (__pyx_t_6 >= __pyx_temp) break; + if (__pyx_t_5 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 238, __pyx_L1_error) + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5)); #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5); #endif + ++__pyx_t_5; } + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 255, __pyx_L1_error) } else { - __pyx_t_1 = __pyx_t_7(__pyx_t_3); + __pyx_t_1 = __pyx_t_6(__pyx_t_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 238, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 255, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } + __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 239, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = (__pyx_t_1 != Py_None); + __pyx_t_7 = (__pyx_t_1 != Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (__pyx_t_8) { + if (__pyx_t_7) { } else { - __pyx_t_2 = __pyx_t_8; + __pyx_t_2 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 240, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = PyObject_IsInstance(__pyx_v_input_arrays, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 240, __pyx_L1_error) + __pyx_t_7 = PyObject_IsInstance(__pyx_v_input_arrays, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(2, 257, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_t_8; + __pyx_t_2 = __pyx_t_7; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_arrays, __pyx_n_s_columns); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_arrays, __pyx_mstate_global->__pyx_n_u_columns); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_1, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 241, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_1, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 258, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_missing, __pyx_t_1); __pyx_t_1 = 0; @@ -51794,31 +42181,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN } /*else*/ { - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_v_input_arrays, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 243, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 243, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_v_input_arrays, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 260, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_missing, __pyx_t_1); __pyx_t_1 = 0; } __pyx_L6:; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_missing); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 244, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_missing); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 261, __pyx_L1_error) if (__pyx_t_2) { - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_missing_keys, __pyx_v_key); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 245, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_missing_keys, __pyx_v_key); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 262, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyList_GET_SIZE(__pyx_v_missing_keys); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(1, 246, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_6 == 0); + __pyx_t_5 = __Pyx_PyList_GET_SIZE(__pyx_v_missing_keys); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 263, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_5 == 0); if (likely(__pyx_t_2)) { - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays, __pyx_v_input_arrays) < 0) __PYX_ERR(1, 247, __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_n_s_outputs_valid, Py_False) < 0) __PYX_ERR(1, 248, __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); @@ -51828,38 +42215,45 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN } /*else*/ { + __pyx_t_1 = NULL; - __pyx_t_6 = __Pyx_PyList_GET_SIZE(__pyx_v_missing_keys); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(1, 252, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_6 > 1); + __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_n_s_s); - __pyx_t_3 = __pyx_n_s_s; + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_s); + __pyx_t_9 = __pyx_mstate_global->__pyx_n_u_s; } else { - __Pyx_INCREF(__pyx_kp_s__6); - __pyx_t_3 = __pyx_kp_s__6; + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__2); + __pyx_t_9 = __pyx_mstate_global->__pyx_kp_u__2; } + __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_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__7, __pyx_v_missing_keys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 254, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 252, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_input_arrays_parameter_missing_r, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 251, __pyx_L1_error) + __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_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_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 268, __pyx_L1_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, 268, __pyx_L1_error) } } @@ -51874,7 +42268,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __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:; @@ -51896,8 +42292,8 @@ PyObject *const *__pyx_args, 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, "\n Returns the function's optional parameters and their default values.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_19get_parameters = {"get_parameters", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -51918,7 +42314,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_parameters (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -51926,47 +42322,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 276, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 259, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_parameters") < 0)) __PYX_ERR(1, 259, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 276, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_parameters", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 259, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_parameters", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 276, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.get_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -51975,11 +42363,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -51994,134 +42379,115 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUS PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; + size_t __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); - PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_parameters", 1); + __Pyx_RefNannySetupContext("get_parameters", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 263, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 280, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 264, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 264, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __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) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_v_ret = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 265, __pyx_L1_error) + __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, 282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { - __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 265, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 265, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 282, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { if (likely(!__pyx_t_6)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { + if (likely(PyList_CheckExact(__pyx_t_3))) { { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 265, __pyx_L1_error) + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 282, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 265, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 265, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_5; } else { { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 265, __pyx_L1_error) + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 282, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 265, __pyx_L1_error) + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5)); #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 265, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5); #endif + ++__pyx_t_5; } + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 282, __pyx_L1_error) } else { - __pyx_t_1 = __pyx_t_6(__pyx_t_2); + __pyx_t_1 = __pyx_t_6(__pyx_t_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 265, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 282, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } + __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__get_opt_input_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 266, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = NULL; + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_4 = 1; - } - } - #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_opt_input}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 266, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_opt_input}; + __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); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - if (unlikely((PyObject_SetItem(__pyx_v_ret, __pyx_v_opt_input, __pyx_t_1) < 0))) __PYX_ERR(1, 266, __pyx_L1_error) + if (unlikely((PyObject_SetItem(__pyx_v_ret, __pyx_v_opt_input, __pyx_t_1) < 0))) __PYX_ERR(2, 283, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ret); @@ -52134,7 +42500,6 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUS __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("talib._ta_lib.Function.get_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -52155,8 +42520,8 @@ PyObject *const *__pyx_args, 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, "\n Sets the function parameter values.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_21set_parameters = {"set_parameters", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -52179,7 +42544,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_parameters (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -52189,62 +42554,53 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; __Pyx_GOTREF(__pyx_v_kwargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_parameters,0}; - values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 286, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 286, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 269, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_parameters); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 269, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values + 0, kwd_pos_args, "set_parameters") < 0)) __PYX_ERR(1, 269, __pyx_L3_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 (!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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 286, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 286, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); } __pyx_v_self = values[0]; __pyx_v_parameters = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("set_parameters", 0, 1, 2, __pyx_nargs); __PYX_ERR(1, 269, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set_parameters", 0, 1, 2, __pyx_nargs); __PYX_ERR(2, 286, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_AddTraceback("talib._ta_lib.Function.set_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -52254,13 +42610,10 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(__pyx_self, __pyx_v_self, __pyx_v_parameters, __pyx_v_kwargs); /* function exit code */ - __Pyx_DECREF(__pyx_v_kwargs); - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __Pyx_DECREF(__pyx_v_kwargs); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -52274,10 +42627,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - Py_ssize_t __pyx_t_6; - PyObject *(*__pyx_t_7)(PyObject *); + size_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *(*__pyx_t_10)(PyObject *); @@ -52287,19 +42640,19 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS __Pyx_RefNannySetupContext("set_parameters", 0); __Pyx_INCREF(__pyx_v_parameters); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_parameters); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 274, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_parameters); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 291, __pyx_L1_error) if (!__pyx_t_2) { } else { __Pyx_INCREF(__pyx_v_parameters); __pyx_t_1 = __pyx_v_parameters; goto __pyx_L3_bool_binop_done; } - __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 274, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; @@ -52308,145 +42661,118 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS __Pyx_DECREF_SET(__pyx_v_parameters, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_parameters, __pyx_n_s_update); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif + __pyx_t_3 = __pyx_v_parameters; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_kwargs}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_kwargs}; + __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); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_parameters, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif + __pyx_t_3 = __pyx_v_parameters; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 276, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __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); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); - __pyx_t_6 = 0; - __pyx_t_7 = NULL; + __pyx_t_5 = 0; + __pyx_t_6 = NULL; } else { - __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 276, __pyx_L1_error) + __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 293, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { - if (likely(!__pyx_t_7)) { + if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_3))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 276, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 293, __pyx_L1_error) #endif - if (__pyx_t_6 >= __pyx_temp) break; + if (__pyx_t_5 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 276, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_5; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 276, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 293, __pyx_L1_error) #endif - if (__pyx_t_6 >= __pyx_temp) break; + if (__pyx_t_5 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 276, __pyx_L1_error) + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5)); #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5); #endif + ++__pyx_t_5; } + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 293, __pyx_L1_error) } else { - __pyx_t_1 = __pyx_t_7(__pyx_t_3); + __pyx_t_1 = __pyx_t_6(__pyx_t_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 276, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 293, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } + __Pyx_GOTREF(__pyx_t_1); if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 276, __pyx_L1_error) + __PYX_ERR(2, 293, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_7); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_8); } else { - __pyx_t_4 = PyList_GET_ITEM(sequence, 0); - __pyx_t_8 = PyList_GET_ITEM(sequence, 1); + __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_GetItemRefFast(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 293, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_8); } - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(__pyx_t_8); #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 276, __pyx_L1_error) + __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; - __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 276, __pyx_L1_error) + __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); - index = 0; __pyx_t_4 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_4)) goto __pyx_L7_unpacking_failed; - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); + index = 0; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L7_unpacking_failed; + __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(1, 276, __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; @@ -52454,48 +42780,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_10 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(1, 276, __pyx_L1_error) + __PYX_ERR(2, 293, __pyx_L1_error) __pyx_L8_unpacking_done:; } - __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_4); - __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__check_opt_input_value); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 277, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - __pyx_t_5 = 1; - } - } - #endif + __pyx_t_8 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_4 = 0; { - PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_param, __pyx_v_value}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 277, __pyx_L1_error) + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_param, __pyx_v_value}; + __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); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 277, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 294, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 278, __pyx_L1_error) + __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, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 278, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_n_s_value, __pyx_v_value) < 0))) __PYX_ERR(1, 278, __pyx_L1_error) + if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_value, __pyx_v_value) < 0))) __PYX_ERR(2, 295, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } @@ -52503,13 +42815,13 @@ 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_n_s_outputs_valid, Py_False) < 0) __PYX_ERR(1, 279, __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_n_s_parameters); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 280, __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); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 280, __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, 297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_n_s_parameters, __pyx_t_3) < 0))) __PYX_ERR(1, 280, __pyx_L1_error) + if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_3) < 0))) __PYX_ERR(2, 297, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -52520,7 +42832,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("talib._ta_lib.Function.set_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -52544,8 +42856,8 @@ PyObject *const *__pyx_args, 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, "\n optional args:[input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs]\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args = {"set_function_args", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -52568,7 +42880,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_function_args (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -52585,48 +42897,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } __Pyx_GOTREF(__pyx_v_args); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { default: - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 301, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 284, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - 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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values + 0, used_pos_args, "set_function_args") < 0)) __PYX_ERR(1, 284, __pyx_L3_error) + 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) + 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) } } } else if (unlikely(__pyx_nargs < 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 301, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("set_function_args", 0, 1, 1, __pyx_nargs); __PYX_ERR(1, 284, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set_function_args", 0, 1, 1, __pyx_nargs); __PYX_ERR(2, 301, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; @@ -52637,14 +42941,11 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(__pyx_self, __pyx_v_self, __pyx_v_args, __pyx_v_kwargs); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_DECREF(__pyx_v_args); __Pyx_DECREF(__pyx_v_kwargs); - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -52667,16 +42968,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U int __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - PyObject *(*__pyx_t_10)(PyObject *); - PyObject *__pyx_t_11 = NULL; + size_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *(*__pyx_t_11)(PyObject *); int __pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_function_args", 1); + __Pyx_RefNannySetupContext("set_function_args", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; @@ -52684,7 +42985,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U __pyx_v_update_info = 0; __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_kwargs, 1, ((PyObject *)NULL), (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 291, __pyx_L1_error) + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_kwargs, 1, ((PyObject *)NULL), (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_5; @@ -52692,59 +42993,45 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U while (1) { __pyx_t_6 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, NULL, NULL, __pyx_t_4); if (unlikely(__pyx_t_6 == 0)) break; - if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(1, 291, __pyx_L1_error) + if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(2, 308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 292, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_5, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 292, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_5, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 309, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_7) { - __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 293, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__check_opt_input_value); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 294, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = NULL; - __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - __pyx_t_6 = 1; - } - } - #endif + __pyx_t_8 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_9 = 0; { - PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_v_key, __pyx_v_value}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 294, __pyx_L1_error) + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_key, __pyx_v_value}; + __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); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 294, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 311, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_7) { - __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 295, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 312, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 295, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 312, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_v_key); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 295, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_v_key); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_9, __pyx_n_s_value, __pyx_t_5) < 0))) __PYX_ERR(1, 295, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely((PyObject_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_value, __pyx_t_5) < 0))) __PYX_ERR(2, 312, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_update_info = 1; @@ -52754,32 +43041,32 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U goto __pyx_L5; } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 297, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_5, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 297, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_5, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 314, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_7) { - __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 298, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 298, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_9, __pyx_v_key); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 298, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_10, __pyx_v_key); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_n_s_price_series, __pyx_t_5) < 0))) __PYX_ERR(1, 298, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_t_5) < 0))) __PYX_ERR(2, 315, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 299, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 299, __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, 316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_n_s_input_names); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_9, __pyx_v_key, __pyx_t_5) < 0))) __PYX_ERR(1, 299, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely((PyObject_SetItem(__pyx_t_10, __pyx_v_key, __pyx_t_5) < 0))) __PYX_ERR(2, 316, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -52787,177 +43074,151 @@ 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 = (PyTuple_GET_SIZE(__pyx_v_args) != 0); + { + 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_int_0); - __pyx_v_skip_first = __pyx_int_0; + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_v_skip_first = __pyx_mstate_global->__pyx_int_0; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_input_arrays); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 303, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = __Pyx_GetItemInt_Tuple(__pyx_v_args, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 303, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_4 = 1; - } - } - #endif + __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, 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_8, __pyx_t_9}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 303, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_10}; + __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) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 303, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 320, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_7) { - __Pyx_INCREF(__pyx_int_1); - __Pyx_DECREF_SET(__pyx_v_skip_first, __pyx_int_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_DECREF_SET(__pyx_v_skip_first, __pyx_mstate_global->__pyx_int_1); } - __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 305, __pyx_L1_error) - __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 305, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 322, __pyx_L1_error) + __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_v_skip_first, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 305, __pyx_L1_error) + __pyx_t_10 = PyObject_RichCompare(__pyx_t_1, __pyx_v_skip_first, Py_GT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 322, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 305, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 322, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (__pyx_t_7) { - __Pyx_INCREF(__pyx_int_0); - __pyx_t_5 = __pyx_int_0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_t_10 = __pyx_mstate_global->__pyx_int_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, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { - __pyx_t_9 = __pyx_t_1; __Pyx_INCREF(__pyx_t_9); + __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __pyx_t_3 = 0; - __pyx_t_10 = NULL; + __pyx_t_11 = NULL; } else { - __pyx_t_3 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 306, __pyx_L1_error) + __pyx_t_3 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 323, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { - if (likely(!__pyx_t_10)) { - if (likely(PyList_CheckExact(__pyx_t_9))) { + if (likely(!__pyx_t_11)) { + if (likely(PyList_CheckExact(__pyx_t_5))) { { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 306, __pyx_L1_error) + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 323, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_9, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 306, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_5, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_3; } else { { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 306, __pyx_L1_error) + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 323, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 306, __pyx_L1_error) + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_3)); #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_3); #endif + ++__pyx_t_3; } + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 323, __pyx_L1_error) } else { - __pyx_t_1 = __pyx_t_10(__pyx_t_9); + __pyx_t_1 = __pyx_t_11(__pyx_t_5); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 306, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 323, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } + __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_1); __pyx_t_1 = 0; - __Pyx_INCREF(__pyx_t_5); - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5); - __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_t_5, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_10); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_10); + __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_t_10, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); - __pyx_t_5 = __pyx_t_1; + __Pyx_DECREF(__pyx_t_10); + __pyx_t_10 = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_i, __pyx_v_skip_first); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 307, __pyx_L1_error) + __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_i, __pyx_v_skip_first); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_i, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 308, __pyx_L1_error) - __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 308, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(2, 325, __pyx_L1_error) + __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = PyObject_RichCompare(__pyx_v_i, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 308, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_i, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 325, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 308, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 325, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (__pyx_t_7) { - __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_args, __pyx_v_i); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 309, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_args, __pyx_v_i); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__check_opt_input_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 310, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_11)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_11); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_1 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; { - PyObject *__pyx_callargs[3] = {__pyx_t_11, __pyx_v_param_name, __pyx_v_value}; - __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 310, __pyx_L1_error) + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_param_name, __pyx_v_value}; + __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); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 310, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 327, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (__pyx_t_7) { - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 311, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_v_param_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 311, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_v_param_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_n_s_value, __pyx_v_value) < 0))) __PYX_ERR(1, 311, __pyx_L1_error) + if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value, __pyx_v_value) < 0))) __PYX_ERR(2, 328, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_update_info = 1; @@ -52967,37 +43228,42 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U } } - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } } - __pyx_t_12 = (PyTuple_GET_SIZE(__pyx_v_args) != 0); + { + 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; goto __pyx_L16_bool_binop_done; } - __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 314, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(2, 331, __pyx_L1_error) __pyx_t_7 = __pyx_t_12; __pyx_L16_bool_binop_done:; if (__pyx_t_7) { if (__pyx_v_update_info) { - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_parameters); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 316, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 316, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely((PyObject_SetItem(__pyx_t_9, __pyx_n_s_parameters, __pyx_t_5) < 0))) __PYX_ERR(1, 316, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_10) < 0))) __PYX_ERR(2, 333, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_n_s_outputs_valid, Py_False) < 0) __PYX_ERR(1, 317, __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) } @@ -53009,8 +43275,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("talib._ta_lib.Function.set_function_args", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -53034,8 +43299,8 @@ PyObject *const *__pyx_args, 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, "\n Returns the lookback window size for the function with the parameter\n values that are currently set.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_25lookback = {"lookback", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -53056,7 +43321,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("lookback (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -53064,47 +43329,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 336, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 319, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "lookback") < 0)) __PYX_ERR(1, 319, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 336, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("lookback", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 319, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("lookback", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 336, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.lookback", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -53113,11 +43370,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_24lookback(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -53141,7 +43395,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyO Py_ssize_t __pyx_t_6; PyObject *(*__pyx_t_7)(PyObject *); PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; int __pyx_t_12; @@ -53151,32 +43405,32 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyO int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("lookback", 1); + __Pyx_RefNannySetupContext("lookback", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 325, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 327, __pyx_L1_error) + __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(1, 327, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(__pyx_t_2); if (unlikely(__pyx_t_3 == ((TA_ParamHolder *)NULL) && PyErr_Occurred())) __PYX_ERR(1, 327, __pyx_L1_error) + __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 == ((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; - __Pyx_INCREF(__pyx_int_0); - __pyx_t_1 = __pyx_int_0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 328, __pyx_L1_error) + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_t_1 = __pyx_mstate_global->__pyx_int_0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { __pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 328, __pyx_L1_error) + __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 328, __pyx_L1_error) + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 345, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; for (;;) { @@ -53184,144 +43438,127 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyO if (likely(PyList_CheckExact(__pyx_t_5))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 328, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 345, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 328, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 328, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif + __pyx_t_4 = __Pyx_PyList_GetItemRefFast(__pyx_t_5, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_6; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 328, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 345, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 328, __pyx_L1_error) + __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6)); #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 328, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_6); #endif + ++__pyx_t_6; } + if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 345, __pyx_L1_error) } else { __pyx_t_4 = __pyx_t_7(__pyx_t_5); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 328, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 345, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_4); } + __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); - __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 328, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_4; __pyx_t_4 = 0; - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__get_opt_input_value); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 329, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = NULL; - __pyx_t_10 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - __pyx_t_10 = 1; - } - } - #endif + __pyx_t_8 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_9 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_opt_input}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 329, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_opt_input}; + __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); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 330, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_v_opt_input); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 330, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_v_opt_input); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_n_s_type_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 330, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_type_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF_SET(__pyx_v_type_, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_RealRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_RealRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(2, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (!__pyx_t_12) { + if (!__pyx_t_11) { } else { - __pyx_t_11 = __pyx_t_12; + __pyx_t_10 = __pyx_t_11; goto __pyx_L6_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_RealList); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_RealList); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(2, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_11 = __pyx_t_12; + __pyx_t_10 = __pyx_t_11; __pyx_L6_bool_binop_done:; - if (__pyx_t_11) { + if (__pyx_t_10) { - __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 332, __pyx_L1_error) - __pyx_t_13 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(1, 332, __pyx_L1_error) - __pyx_t_14 = __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(__pyx_v_holder, __pyx_t_10, __pyx_t_13); if (unlikely(__pyx_t_14 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(1, 332, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyLong_As_int(__pyx_v_i); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 349, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 349, __pyx_L1_error) + __pyx_t_14 = __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(__pyx_v_holder, __pyx_t_12, __pyx_t_13); if (unlikely(__pyx_t_14 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 349, __pyx_L1_error) goto __pyx_L5; } - __pyx_t_4 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_IntegerRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 333, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_IntegerRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 333, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 350, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 333, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(2, 350, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (!__pyx_t_12) { + if (!__pyx_t_11) { } else { - __pyx_t_11 = __pyx_t_12; + __pyx_t_10 = __pyx_t_11; goto __pyx_L8_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_IntegerList); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 333, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_IntegerList); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 333, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 350, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(1, 333, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(2, 350, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_11 = __pyx_t_12; + __pyx_t_10 = __pyx_t_11; __pyx_L8_bool_binop_done:; - if (__pyx_t_11) { + if (__pyx_t_10) { - __pyx_t_14 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_14 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 334, __pyx_L1_error) - __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 334, __pyx_L1_error) - __pyx_t_15 = __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(__pyx_v_holder, __pyx_t_14, __pyx_t_10); if (unlikely(__pyx_t_15 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(1, 334, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyLong_As_int(__pyx_v_i); if (unlikely((__pyx_t_14 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 351, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 351, __pyx_L1_error) + __pyx_t_15 = __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(__pyx_v_holder, __pyx_t_14, __pyx_t_12); if (unlikely(__pyx_t_15 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 351, __pyx_L1_error) } __pyx_L5:; @@ -53330,13 +43567,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyO __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_15 = __pyx_f_5talib_7_ta_lib___ta_getLookback(__pyx_v_holder); if (unlikely(__pyx_t_15 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(1, 336, __pyx_L1_error) + __pyx_t_15 = __pyx_f_5talib_7_ta_lib___ta_getLookback(__pyx_v_holder); if (unlikely(__pyx_t_15 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 353, __pyx_L1_error) __pyx_v_lookback = __pyx_t_15; - __pyx_t_15 = __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(__pyx_v_holder); if (unlikely(__pyx_t_15 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(1, 337, __pyx_L1_error) + __pyx_t_15 = __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(__pyx_v_holder); if (unlikely(__pyx_t_15 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 354, __pyx_L1_error) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_lookback); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 338, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_lookback); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -53349,7 +43586,6 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyO __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("talib._ta_lib.Function.lookback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -53372,8 +43608,8 @@ PyObject *const *__pyx_args, 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, "\n Returns a list of the output names returned by this function.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_27output_names = {"output_names", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -53394,7 +43630,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("output_names (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -53402,47 +43638,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 357, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 340, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "output_names") < 0)) __PYX_ERR(1, 340, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 357, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("output_names", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 340, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("output_names", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 357, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.output_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -53451,11 +43679,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_26output_names(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -53468,52 +43693,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_26output_names(CYTHON_UNUSED PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; int __pyx_t_6; + int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("output_names", 1); + __Pyx_RefNannySetupContext("output_names", 0); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 345, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_outputs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 345, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_keys); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 345, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_2 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 345, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __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) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_v_ret = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_5 = PyList_Check(__pyx_v_ret); - __pyx_t_6 = (!__pyx_t_5); - if (__pyx_t_6) { + __pyx_t_6 = PyList_Check(__pyx_v_ret); + __pyx_t_7 = (!__pyx_t_6); + if (__pyx_t_7) { - __pyx_t_1 = PySequence_List(__pyx_v_ret); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 347, __pyx_L1_error) + __pyx_t_1 = PySequence_List(__pyx_v_ret); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 364, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_ret, __pyx_t_1); __pyx_t_1 = 0; @@ -53531,6 +43743,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_26output_names(CYTHON_UNUSED __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("talib._ta_lib.Function.output_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -53549,8 +43762,8 @@ PyObject *const *__pyx_args, 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, "\n Returns the TA function values for the currently set input_arrays and\n parameters. Returned values are a ndarray if there is only one output\n or a list of ndarrays for more than one output.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_29outputs = {"outputs", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -53571,7 +43784,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("outputs (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -53579,47 +43792,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 367, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 350, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "outputs") < 0)) __PYX_ERR(1, 350, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 367, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("outputs", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 350, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("outputs", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 367, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.outputs", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -53628,11 +43833,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_28outputs(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -53648,81 +43850,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("outputs", 1); + __Pyx_RefNannySetupContext("outputs", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 357, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_outputs_valid); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 358, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 358, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 375, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (!__pyx_t_2); if (__pyx_t_3) { - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__call_function); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 359, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } - } - #endif + __pyx_t_4 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 359, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __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); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_outputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 360, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_values); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 360, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } - } - #endif + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __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; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 360, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_v_ret = __pyx_t_1; __pyx_t_1 = 0; @@ -53731,14 +43908,14 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb __pyx_t_2 = (!__pyx_t_3); if (__pyx_t_2) { - __pyx_t_1 = PySequence_List(__pyx_v_ret); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 362, __pyx_L1_error) + __pyx_t_1 = PySequence_List(__pyx_v_ret); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_ret, __pyx_t_1); __pyx_t_1 = 0; } - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 363, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = (__pyx_t_1 != Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -53748,223 +43925,256 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb goto __pyx_L6_bool_binop_done; } - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 364, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 364, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = PyObject_IsInstance(__pyx_t_1, __pyx_t_5); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 364, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyObject_IsInstance(__pyx_t_1, __pyx_t_6); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 381, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = __pyx_t_3; __pyx_L6_bool_binop_done:; if (__pyx_t_2) { - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 365, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 365, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 382, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_index = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 366, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 383, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 == 1); if (__pyx_t_2) { __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PANDAS_SERIES); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 367, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 367, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 367, __pyx_L1_error) + __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_GIVEREF(__pyx_t_5); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5)) __PYX_ERR(1, 367, __pyx_L1_error); - __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 367, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_index, __pyx_v_index) < 0) __PYX_ERR(1, 367, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 367, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_r = __pyx_t_8; - __pyx_t_8 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + 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((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; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; } /*else*/ { __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 369, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 369, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_column_stack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 369, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; - __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_numpy); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_column_stack); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - __pyx_t_6 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_11); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_11, __pyx__function); + __pyx_t_5 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_ret}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 369, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_ret}; + __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) + __Pyx_GOTREF(__pyx_t_8); } - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 369, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5)) __PYX_ERR(1, 369, __pyx_L1_error); - __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 370, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_index, __pyx_v_index) < 0) __PYX_ERR(1, 370, __pyx_L1_error) - - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_output_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 371, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_columns, __pyx_t_4) < 0) __PYX_ERR(1, 370, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 369, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_9, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + 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((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; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; } } - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_POLARS_DATAFRAME); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 372, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = (__pyx_t_4 != Py_None); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_t_1 != Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L9_bool_binop_done; } - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 373, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_POLARS_DATAFRAME); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 373, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = PyObject_IsInstance(__pyx_t_4, __pyx_t_5); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 373, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = PyObject_IsInstance(__pyx_t_1, __pyx_t_9); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 390, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_2 = __pyx_t_3; __pyx_L9_bool_binop_done:; if (__pyx_t_2) { - __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 374, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 391, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 == 1); if (__pyx_t_2) { __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_POLARS_SERIES); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 375, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 375, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = NULL; - __pyx_t_6 = 0; + __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, 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 - if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_5 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_1}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 375, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_11}; + __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; + if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); } - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; goto __pyx_L0; } /*else*/ { __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_POLARS_DATAFRAME); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 377, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 377, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_column_stack); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 377, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - __pyx_t_6 = 0; + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_column_stack); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - __pyx_t_6 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_10, __pyx__function); + __pyx_t_5 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_ret}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 377, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_ret}; + __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) + __Pyx_GOTREF(__pyx_t_1); } - __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 377, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4)) __PYX_ERR(1, 377, __pyx_L1_error); - __pyx_t_4 = 0; - - __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 378, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_output_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 378, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_schema, __pyx_t_1) < 0) __PYX_ERR(1, 378, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 377, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_11); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_11, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + 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((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; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + } + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; goto __pyx_L0; } @@ -53972,19 +44182,19 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb /*else*/ { __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 380, __pyx_L1_error) + __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_4 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 380, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __pyx_t_4; - __pyx_t_4 = 0; + __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; } else { __Pyx_INCREF(__pyx_v_ret); - __pyx_t_1 = __pyx_v_ret; + __pyx_t_9 = __pyx_v_ret; } - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; goto __pyx_L0; } @@ -53993,8 +44203,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("talib._ta_lib.Function.outputs", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -54015,8 +44228,8 @@ PyObject *const *__pyx_args, 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, "\n run([input_arrays=None])\n\n This is a shortcut to the outputs property that also allows setting\n the input_arrays dict.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_31run = {"run", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -54038,7 +44251,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("run (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -54046,62 +44259,53 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_arrays,0}; - values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 399, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 399, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 382, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_input_arrays); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 382, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "run") < 0)) __PYX_ERR(1, 382, __pyx_L3_error) + const Py_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 (!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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 399, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 399, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); } __pyx_v_self = values[0]; __pyx_v_input_arrays = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("run", 0, 1, 2, __pyx_nargs); __PYX_ERR(1, 382, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("run", 0, 1, 2, __pyx_nargs); __PYX_ERR(2, 399, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.run", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -54110,11 +44314,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_30run(__pyx_self, __pyx_v_self, __pyx_v_input_arrays); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -54126,72 +44327,43 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_30run(CYTHON_UNUSED PyObject int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; + size_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("run", 1); + __Pyx_RefNannySetupContext("run", 0); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_input_arrays); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 389, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_input_arrays); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(2, 406, __pyx_L1_error) if (__pyx_t_1) { - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_input_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 390, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_input_arrays}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 390, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_input_arrays}; + __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); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__call_function); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 391, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 391, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __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); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 392, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; @@ -54202,7 +44374,6 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_30run(CYTHON_UNUSED PyObject __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("talib._ta_lib.Function.run", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -54220,8 +44391,8 @@ PyObject *const *__pyx_args, 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__, "\n func_instance([input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs])\n\n This is a shortcut to the outputs property that also allows setting\n the input_arrays dict and function parameters.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_33__call__ = {"__call__", (PyCFunction)(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__}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -54244,7 +44415,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -54261,48 +44432,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } __Pyx_GOTREF(__pyx_v_args); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { default: - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 411, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 394, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - 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 (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values + 0, used_pos_args, "__call__") < 0)) __PYX_ERR(1, 394, __pyx_L3_error) + 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) + 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) } } } else if (unlikely(__pyx_nargs < 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 411, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 0, 1, 1, __pyx_nargs); __PYX_ERR(1, 394, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__call__", 0, 1, 1, __pyx_nargs); __PYX_ERR(2, 411, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; @@ -54313,14 +44476,11 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_32__call__(__pyx_self, __pyx_v_self, __pyx_v_args, __pyx_v_kwargs); /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } __Pyx_DECREF(__pyx_v_args); __Pyx_DECREF(__pyx_v_kwargs); - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -54345,7 +44505,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; + size_t __pyx_t_5; Py_ssize_t __pyx_t_6; PyObject *(*__pyx_t_7)(PyObject *); int __pyx_t_8; @@ -54354,61 +44514,49 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; - PyObject *__pyx_t_14 = NULL; - Py_ssize_t __pyx_t_15; - PyObject *__pyx_t_16 = NULL; + int __pyx_t_14; + PyObject *__pyx_t_15 = NULL; + Py_ssize_t __pyx_t_16; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; - PyObject *(*__pyx_t_19)(PyObject *); + PyObject *__pyx_t_19[5]; + PyObject *__pyx_t_20 = NULL; + PyObject *(*__pyx_t_21)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call__", 0); __Pyx_INCREF(__pyx_v_args); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 401, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 403, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 404, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_keys); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 404, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; + __pyx_t_3 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_5 = 1; - } - } - #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __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; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 404, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { __pyx_t_4 = __pyx_t_2; __Pyx_INCREF(__pyx_t_4); __pyx_t_6 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_6 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 404, __pyx_L1_error) + __pyx_t_6 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 404, __pyx_L1_error) + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 421, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; for (;;) { @@ -54416,64 +44564,61 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO if (likely(PyList_CheckExact(__pyx_t_4))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 404, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 421, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 404, __pyx_L1_error) - #else - __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 404, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - #endif + __pyx_t_2 = __Pyx_PyList_GetItemRefFast(__pyx_t_4, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_6; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 404, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 421, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 404, __pyx_L1_error) + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_6)); #else - __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 404, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_6); #endif + ++__pyx_t_6; } + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 421, __pyx_L1_error) } else { __pyx_t_2 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 404, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 421, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_2); } + __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 403, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_param_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 403, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_param_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 403, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 403, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_param_name); __Pyx_GIVEREF(__pyx_v_param_name); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_param_name)) __PYX_ERR(1, 403, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_param_name) != (0)) __PYX_ERR(2, 420, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2)) __PYX_ERR(1, 403, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(2, 420, __pyx_L1_error); __pyx_t_2 = 0; - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(1, 403, __pyx_L1_error) + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(2, 420, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } @@ -54481,19 +44626,19 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_v_opt_input_values = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 405, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 406, __pyx_L1_error) + __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, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { __pyx_t_3 = __pyx_t_4; __Pyx_INCREF(__pyx_t_3); __pyx_t_6 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 406, __pyx_L1_error) + __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 406, __pyx_L1_error) + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 423, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; for (;;) { @@ -54501,64 +44646,61 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO if (likely(PyList_CheckExact(__pyx_t_3))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 406, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 423, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 406, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 406, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif + __pyx_t_4 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_6; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 406, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 423, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 406, __pyx_L1_error) + __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6)); #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 406, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6); #endif + ++__pyx_t_6; } + if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 423, __pyx_L1_error) } else { __pyx_t_4 = __pyx_t_7(__pyx_t_3); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 406, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 423, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_4); } + __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 405, __pyx_L1_error) + __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, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 405, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_s_price_series); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 405, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_price_series); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 405, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_n); __Pyx_GIVEREF(__pyx_v_n); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_n)) __PYX_ERR(1, 405, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_n) != (0)) __PYX_ERR(2, 422, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(1, 405, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4) != (0)) __PYX_ERR(2, 422, __pyx_L1_error); __pyx_t_4 = 0; - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 405, __pyx_L1_error) + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(2, 422, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } @@ -54566,54 +44708,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_v_price_series_name_values = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PySequence_List(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 409, __pyx_L1_error) + __pyx_t_1 = PySequence_List(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_args, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 410, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_input_arrays = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_price_series_na); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = NULL; + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 411, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __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); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_input_price_series_names = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_args); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(1, 412, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_args); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 429, __pyx_L1_error) if (__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L10_bool_binop_done; } - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 412, __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_n_s_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 412, __pyx_L1_error) + __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); - __pyx_t_9 = PyObject_IsInstance(__pyx_t_1, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 412, __pyx_L1_error) + __pyx_t_9 = PyObject_IsInstance(__pyx_t_1, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 429, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_10 = (!__pyx_t_9); @@ -54621,73 +44749,70 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_L10_bool_binop_done:; if (__pyx_t_8) { - __Pyx_INCREF(__pyx_int_0); - __pyx_t_3 = __pyx_int_0; + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_t_3 = __pyx_mstate_global->__pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_args)) || PyTuple_CheckExact(__pyx_v_args)) { __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_6 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 413, __pyx_L1_error) + __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 413, __pyx_L1_error) + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 430, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_1))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 413, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 430, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 413, __pyx_L1_error) - #else - __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 413, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - #endif + __pyx_t_2 = __Pyx_PyList_GetItemRefFast(__pyx_t_1, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_6; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 413, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 430, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 413, __pyx_L1_error) + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6)); #else - __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 413, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6); #endif + ++__pyx_t_6; } + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 430, __pyx_L1_error) } else { __pyx_t_2 = __pyx_t_7(__pyx_t_1); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 413, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 430, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_2); } + __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); - __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 413, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = __pyx_t_2; __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ARRAY_TYPES); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 414, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = PyObject_IsInstance(__pyx_v_arg, __pyx_t_2); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 414, __pyx_L1_error) + __pyx_t_8 = PyObject_IsInstance(__pyx_v_arg, __pyx_t_2); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 431, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_10 = (!__pyx_t_8); if (__pyx_t_10) { @@ -54705,9 +44830,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __Pyx_XGOTREF(__pyx_t_13); /*try:*/ { - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_input_price_series_names, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L15_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_input_price_series_names, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 435, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_2); - if (unlikely((PyDict_SetItem(__pyx_v_input_arrays, __pyx_t_2, __pyx_v_arg) < 0))) __PYX_ERR(1, 418, __pyx_L15_error) + if (unlikely((PyDict_SetItem(__pyx_v_input_arrays, __pyx_t_2, __pyx_v_arg) < 0))) __PYX_ERR(2, 435, __pyx_L15_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } @@ -54719,41 +44844,46 @@ 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_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_IndexError); - if (__pyx_t_5) { + __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_14) < 0) __PYX_ERR(1, 419, __pyx_L17_except_error) + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_15) < 0) __PYX_ERR(2, 436, __pyx_L17_except_error) __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_14); - - __pyx_t_15 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 421, __pyx_L17_except_error) - __pyx_t_16 = PyInt_FromSsize_t(__pyx_t_15); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 421, __pyx_L17_except_error) - __Pyx_GOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_15); - __pyx_t_17 = __Pyx_PyString_Join(__pyx_kp_s__7, __pyx_v_input_price_series_names); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 422, __pyx_L17_except_error) + __pyx_t_16 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 438, __pyx_L17_except_error) + __pyx_t_17 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_16, 0, ' ', 'd'); if (unlikely(!__pyx_t_17)) __PYX_ERR(2, 438, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_17); - __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 421, __pyx_L17_except_error) + __pyx_t_18 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_input_price_series_names); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 439, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_16); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_16)) __PYX_ERR(1, 421, __pyx_L17_except_error); - __Pyx_GIVEREF(__pyx_t_17); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_17)) __PYX_ERR(1, 421, __pyx_L17_except_error); - __pyx_t_16 = 0; - __pyx_t_17 = 0; - - __pyx_t_17 = __Pyx_PyString_Format(__pyx_kp_s_Too_many_price_arguments_expecte, __pyx_t_18); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 420, __pyx_L17_except_error) - __Pyx_GOTREF(__pyx_t_17); + __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Too_many_price_arguments_expecte; + __pyx_t_19[1] = __pyx_t_17; + __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u__4; + __pyx_t_19[3] = __pyx_t_18; + __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u__5; + + __pyx_t_20 = __Pyx_PyUnicode_Join(__pyx_t_19, 5, 35 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_17) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_18)); + if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 437, __pyx_L17_except_error) + __Pyx_GOTREF(__pyx_t_20); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __pyx_v_msg = ((PyObject*)__pyx_t_17); - __pyx_t_17 = 0; + __pyx_v_msg = ((PyObject*)__pyx_t_20); + __pyx_t_20 = 0; - __pyx_t_17 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_v_msg); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 423, __pyx_L17_except_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_Raise(__pyx_t_17, 0, 0, 0); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __PYX_ERR(1, 423, __pyx_L17_except_error) + __pyx_t_18 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_18, __pyx_v_msg}; + __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; + if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 440, __pyx_L17_except_error) + __Pyx_GOTREF(__pyx_t_20); + } + __Pyx_Raise(__pyx_t_20, 0, 0, 0); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __PYX_ERR(2, 440, __pyx_L17_except_error) } goto __pyx_L17_except_error; @@ -54777,7 +44907,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO } - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 442, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = (__pyx_t_3 != Py_None); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -54787,11 +44917,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO goto __pyx_L27_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 426, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 443, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 426, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 443, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = PyObject_IsInstance(__pyx_t_3, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 426, __pyx_L1_error) + __pyx_t_8 = PyObject_IsInstance(__pyx_t_3, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 443, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_10 = __pyx_t_8; @@ -54799,9 +44929,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO if (__pyx_t_10) { - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 444, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 427, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 444, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_no_existing_input_arrays = __pyx_t_3; @@ -54810,7 +44940,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO goto __pyx_L26; } - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_POLARS_DATAFRAME); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 428, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = (__pyx_t_3 != Py_None); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -54820,11 +44950,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO goto __pyx_L29_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 429, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = PyObject_IsInstance(__pyx_t_3, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 429, __pyx_L1_error) + __pyx_t_8 = PyObject_IsInstance(__pyx_t_3, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 446, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_10 = __pyx_t_8; @@ -54832,32 +44962,18 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO if (__pyx_t_10) { - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 430, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_is_empty); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 430, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_3 = __pyx_t_15; + __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_14))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_14); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_14, function); - __pyx_t_5 = 1; - } - } - #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __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; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 430, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; } __pyx_v_no_existing_input_arrays = __pyx_t_1; __pyx_t_1 = 0; @@ -54866,50 +44982,36 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO } /*else*/ { - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 432, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(1, 432, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 449, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyBool_FromLong((!(!(!__pyx_t_10)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 432, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong((!(!(!__pyx_t_10)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_no_existing_input_arrays = __pyx_t_1; __pyx_t_1 = 0; } __pyx_L26:; - __pyx_t_6 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(1, 434, __pyx_L1_error) - __pyx_t_15 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 434, __pyx_L1_error) - __pyx_t_10 = (__pyx_t_6 == __pyx_t_15); + __pyx_t_6 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(2, 451, __pyx_L1_error) + __pyx_t_16 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 451, __pyx_L1_error) + __pyx_t_10 = (__pyx_t_6 == __pyx_t_16); if (__pyx_t_10) { - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_input_arrays); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 435, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = NULL; + __pyx_t_15 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_15); __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_14))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_14); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_14, function); - __pyx_t_5 = 1; - } - } - #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_input_arrays}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 435, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_15, __pyx_v_input_arrays}; + __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); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_15 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 436, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyList_GetSlice(__pyx_v_args, __pyx_t_15, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 436, __pyx_L1_error) + __pyx_t_16 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 453, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyList_GetSlice(__pyx_v_args, __pyx_t_16, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_args, __pyx_t_1); __pyx_t_1 = 0; @@ -54917,284 +45019,279 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO goto __pyx_L31; } - __pyx_t_15 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 437, __pyx_L1_error) - __pyx_t_8 = (__pyx_t_15 != 0); + __pyx_t_16 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 454, __pyx_L1_error) + __pyx_t_8 = (__pyx_t_16 != 0); if (!__pyx_t_8) { } else { __pyx_t_10 = __pyx_t_8; goto __pyx_L32_bool_binop_done; } - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_no_existing_input_arrays); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 437, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_no_existing_input_arrays); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 454, __pyx_L1_error) if (__pyx_t_8) { } else { __pyx_t_10 = __pyx_t_8; goto __pyx_L32_bool_binop_done; } - __pyx_t_15 = PyObject_Length(__pyx_v_args); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 438, __pyx_L1_error) - __pyx_t_8 = (!(__pyx_t_15 != 0)); + __pyx_t_16 = PyObject_Length(__pyx_v_args); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 455, __pyx_L1_error) + __pyx_t_8 = (!(__pyx_t_16 != 0)); if (!__pyx_t_8) { } else { __pyx_t_10 = __pyx_t_8; goto __pyx_L32_bool_binop_done; } - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 438, __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_14, __pyx_n_s_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 438, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_8 = PyObject_IsInstance(__pyx_t_1, __pyx_t_14); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 438, __pyx_L1_error) + __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); + __pyx_t_8 = PyObject_IsInstance(__pyx_t_1, __pyx_t_15); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 455, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_9 = (!__pyx_t_8); __pyx_t_10 = __pyx_t_9; __pyx_L32_bool_binop_done:; if (unlikely(__pyx_t_10)) { - __pyx_t_15 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 440, __pyx_L1_error) - __pyx_t_14 = PyInt_FromSsize_t(__pyx_t_15); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 440, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); + __pyx_t_16 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 457, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_16, 0, ' ', 'd'); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); - __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__7, __pyx_v_input_price_series_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 441, __pyx_L1_error) + __pyx_t_1 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_input_price_series_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 440, __pyx_L1_error) + __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Not_enough_price_arguments_expec; + __pyx_t_19[1] = __pyx_t_15; + __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u__4; + __pyx_t_19[3] = __pyx_t_1; + __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u__5; + + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_19, 5, 37 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1)); + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_14)) __PYX_ERR(1, 440, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 440, __pyx_L1_error); - __pyx_t_14 = 0; - __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_msg = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Not_enough_price_arguments_expec, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 439, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_msg}; + __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; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_msg = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_v_msg); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 442, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 442, __pyx_L1_error) + __PYX_ERR(2, 459, __pyx_L1_error) } __pyx_L31:; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_function_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 444, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 444, __pyx_L1_error) + __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_14 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 444, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_14); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 444, __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_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_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 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_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__call_function); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 445, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = NULL; + __pyx_t_15 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_15); __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_14))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_14); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_14, function); - __pyx_t_5 = 1; - } - } - #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 445, __pyx_L1_error) + 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); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __pyx_v_opt_input_values; __Pyx_INCREF(__pyx_t_4); - __pyx_t_15 = 0; + __pyx_t_16 = 0; for (;;) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 448, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 465, __pyx_L1_error) #endif - if (__pyx_t_15 >= __pyx_temp) break; + if (__pyx_t_16 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_14 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_15); __Pyx_INCREF(__pyx_t_14); __pyx_t_15++; if (unlikely((0 < 0))) __PYX_ERR(1, 448, __pyx_L1_error) - #else - __pyx_t_14 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 448, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_14))) || (PyList_CheckExact(__pyx_t_14))) { - PyObject* sequence = __pyx_t_14; + __pyx_t_15 = __Pyx_PyList_GetItemRefFast(__pyx_t_4, __pyx_t_16, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_16; + 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); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 448, __pyx_L1_error) + __PYX_ERR(2, 465, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); + __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_3 = PyList_GET_ITEM(sequence, 0); - __pyx_t_1 = PyList_GET_ITEM(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); } - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 448, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 448, __pyx_L1_error) + __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_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else { Py_ssize_t index = -1; - __pyx_t_2 = PyObject_GetIter(__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 448, __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_14); __pyx_t_14 = 0; - __pyx_t_19 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); - index = 0; __pyx_t_3 = __pyx_t_19(__pyx_t_2); if (unlikely(!__pyx_t_3)) goto __pyx_L38_unpacking_failed; - __Pyx_GOTREF(__pyx_t_3); - index = 1; __pyx_t_1 = __pyx_t_19(__pyx_t_2); if (unlikely(!__pyx_t_1)) goto __pyx_L38_unpacking_failed; + __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_1 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_1)) goto __pyx_L38_unpacking_failed; __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_19(__pyx_t_2), 2) < 0) __PYX_ERR(1, 448, __pyx_L1_error) - __pyx_t_19 = NULL; + 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) + __pyx_t_21 = NULL; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L39_unpacking_done; __pyx_L38_unpacking_failed:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_19 = NULL; + __pyx_t_21 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(1, 448, __pyx_L1_error) + __PYX_ERR(2, 465, __pyx_L1_error) __pyx_L39_unpacking_done:; } - __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1); + __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_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 449, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_14, __pyx_v_param_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 449, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_n_s_value, __pyx_v_value) < 0))) __PYX_ERR(1, 449, __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_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_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; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_parameters); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 450, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 450, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_n_s_parameters, __pyx_t_4) < 0))) __PYX_ERR(1, 450, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_4) < 0))) __PYX_ERR(2, 467, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __pyx_v_price_series_name_values; __Pyx_INCREF(__pyx_t_4); - __pyx_t_15 = 0; + __pyx_t_16 = 0; for (;;) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 453, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 470, __pyx_L1_error) #endif - if (__pyx_t_15 >= __pyx_temp) break; + if (__pyx_t_16 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_15); __Pyx_INCREF(__pyx_t_1); __pyx_t_15++; if (unlikely((0 < 0))) __PYX_ERR(1, 453, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 453, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif - if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { - PyObject* sequence = __pyx_t_1; + __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); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 453, __pyx_L1_error) + __PYX_ERR(2, 470, __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_t_3 = 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_14 = PyList_GET_ITEM(sequence, 0); - __pyx_t_3 = PyList_GET_ITEM(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); } - __Pyx_INCREF(__pyx_t_14); - __Pyx_INCREF(__pyx_t_3); #else - __pyx_t_14 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 453, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 453, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __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_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { Py_ssize_t index = -1; - __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 453, __pyx_L1_error) + __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_19 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); - index = 0; __pyx_t_14 = __pyx_t_19(__pyx_t_2); if (unlikely(!__pyx_t_14)) goto __pyx_L43_unpacking_failed; - __Pyx_GOTREF(__pyx_t_14); - index = 1; __pyx_t_3 = __pyx_t_19(__pyx_t_2); if (unlikely(!__pyx_t_3)) goto __pyx_L43_unpacking_failed; - __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_19(__pyx_t_2), 2) < 0) __PYX_ERR(1, 453, __pyx_L1_error) - __pyx_t_19 = NULL; + __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_15 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_15)) goto __pyx_L43_unpacking_failed; + __Pyx_GOTREF(__pyx_t_15); + 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; __pyx_L43_unpacking_failed:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_19 = NULL; + __pyx_t_21 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(1, 453, __pyx_L1_error) + __PYX_ERR(2, 470, __pyx_L1_error) __pyx_L44_unpacking_done:; } - __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_14); - __pyx_t_14 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_3); - __pyx_t_3 = 0; + __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_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 454, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 454, __pyx_L1_error) + __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_n_s_price_series, __pyx_v_value) < 0))) __PYX_ERR(1, 454, __pyx_L1_error) + __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_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_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 455, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 455, __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_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_input_name, __pyx_v_value) < 0))) __PYX_ERR(1, 455, __pyx_L1_error) + __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_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; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_outputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 457, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; @@ -55207,10 +45304,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_14); - __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_15); __Pyx_XDECREF(__pyx_t_17); __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_20); __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -55242,7 +45339,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names = {"__input_price_series_names", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_35__input_price_series_names, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_34__input_price_series_names, "Function.__input_price_series_names(self)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names = {"__input_price_series_names", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_35__input_price_series_names, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_34__input_price_series_names}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_35__input_price_series_names(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -55263,7 +45361,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__input_price_series_names (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -55271,47 +45369,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 477, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 460, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__input_price_series_names") < 0)) __PYX_ERR(1, 460, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 477, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__input_price_series_names", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 460, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__input_price_series_names", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 477, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.__input_price_series_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -55320,11 +45410,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -55350,28 +45437,28 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__input_price_series_names", 1); + __Pyx_RefNannySetupContext("__input_price_series_names", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 461, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 462, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_input_price_series_names = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 463, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 463, __pyx_L1_error) + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 463, __pyx_L1_error) + __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 480, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { @@ -55379,53 +45466,50 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 463, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 480, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 463, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 463, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_3; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 463, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 480, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 463, __pyx_L1_error) + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3)); #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 463, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); #endif + ++__pyx_t_3; } + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 480, __pyx_L1_error) } else { __pyx_t_1 = __pyx_t_4(__pyx_t_2); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 463, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 480, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } + __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 464, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 464, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_n_s_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 464, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_price_series, __pyx_t_1); @@ -55439,57 +45523,54 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names __pyx_t_7 = 0; __pyx_t_8 = NULL; } else { - __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 466, __pyx_L1_error) + __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 466, __pyx_L1_error) + __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 483, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_8)) { if (likely(PyList_CheckExact(__pyx_t_1))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 466, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 483, __pyx_L1_error) #endif if (__pyx_t_7 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_5); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(1, 466, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 466, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif + __pyx_t_5 = __Pyx_PyList_GetItemRefFast(__pyx_t_1, __pyx_t_7, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_7; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 466, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 483, __pyx_L1_error) #endif if (__pyx_t_7 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_5); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(1, 466, __pyx_L1_error) + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7)); #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 466, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); #endif + ++__pyx_t_7; } + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 483, __pyx_L1_error) } else { __pyx_t_5 = __pyx_t_8(__pyx_t_1); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 466, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 483, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_5); } + __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_input_price_series_names, __pyx_v_name); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 467, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_input_price_series_names, __pyx_v_name); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 484, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -55498,7 +45579,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names } /*else*/ { - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_input_price_series_names, __pyx_v_price_series); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 469, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_input_price_series_names, __pyx_v_price_series); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 486, __pyx_L1_error) } __pyx_L5:; @@ -55538,7 +45619,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_37__call_function = {"__call_function", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_37__call_function, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_36__call_function, "Function.__call_function(self)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_37__call_function = {"__call_function", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_37__call_function, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_36__call_function}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_37__call_function(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -55559,7 +45641,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__call_function (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -55567,47 +45649,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 489, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 472, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call_function") < 0)) __PYX_ERR(1, 472, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 489, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call_function", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 472, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__call_function", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 489, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.__call_function", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -55616,11 +45690,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_36__call_function(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -55642,10 +45713,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - Py_ssize_t __pyx_t_5; - PyObject *(*__pyx_t_6)(PyObject *); + size_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *(*__pyx_t_5)(PyObject *); + PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; @@ -55654,369 +45725,279 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__call_function", 1); + __Pyx_RefNannySetupContext("__call_function", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 473, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_price_series_na); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 474, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 474, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __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); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_v_input_price_series_names = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 477, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_args = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; if (likely(PyList_CheckExact(__pyx_v_input_price_series_names)) || PyTuple_CheckExact(__pyx_v_input_price_series_names)) { __pyx_t_1 = __pyx_v_input_price_series_names; __Pyx_INCREF(__pyx_t_1); - __pyx_t_5 = 0; - __pyx_t_6 = NULL; + __pyx_t_4 = 0; + __pyx_t_5 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_input_price_series_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 478, __pyx_L1_error) + __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_input_price_series_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 478, __pyx_L1_error) + __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 495, __pyx_L1_error) } for (;;) { - if (likely(!__pyx_t_6)) { + if (likely(!__pyx_t_5)) { if (likely(PyList_CheckExact(__pyx_t_1))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 478, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 495, __pyx_L1_error) #endif - if (__pyx_t_5 >= __pyx_temp) break; + if (__pyx_t_4 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 478, __pyx_L1_error) - #else - __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - #endif + __pyx_t_2 = __Pyx_PyList_GetItemRefFast(__pyx_t_1, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 478, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 495, __pyx_L1_error) #endif - if (__pyx_t_5 >= __pyx_temp) break; + if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 478, __pyx_L1_error) + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4)); #else - __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); #endif + ++__pyx_t_4; } + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 495, __pyx_L1_error) } else { - __pyx_t_2 = __pyx_t_6(__pyx_t_1); + __pyx_t_2 = __pyx_t_5(__pyx_t_1); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 478, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 495, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_2); } + __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_price_series, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_input_arrays); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 479, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_price_series); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 479, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_price_series); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF_SET(__pyx_v_series, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_series, __pyx_t_6); + __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PANDAS_SERIES); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 480, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = (__pyx_t_3 != Py_None); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = (__pyx_t_6 != Py_None); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_8) { } else { __pyx_t_7 = __pyx_t_8; goto __pyx_L6_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PANDAS_SERIES); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 481, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = PyObject_IsInstance(__pyx_v_series, __pyx_t_3); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 481, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyObject_IsInstance(__pyx_v_series, __pyx_t_6); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 498, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __pyx_t_8; __pyx_L6_bool_binop_done:; if (__pyx_t_7) { - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_series, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 482, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_astype); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 482, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_series, __pyx_mstate_global->__pyx_n_u_values); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_9))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_9, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_2 = __pyx_t_9; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)(&PyFloat_Type))}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __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; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 482, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); } - __Pyx_DECREF_SET(__pyx_v_series, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_series, __pyx_t_6); + __pyx_t_6 = 0; goto __pyx_L5; } - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_POLARS_SERIES); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 483, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = (__pyx_t_3 != Py_None); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = (__pyx_t_6 != Py_None); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_8) { } else { __pyx_t_7 = __pyx_t_8; goto __pyx_L8_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_POLARS_SERIES); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 484, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = PyObject_IsInstance(__pyx_v_series, __pyx_t_3); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 484, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyObject_IsInstance(__pyx_v_series, __pyx_t_6); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __pyx_t_8; __pyx_L8_bool_binop_done:; if (__pyx_t_7) { - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_series, __pyx_n_s_to_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_10 = __pyx_v_series; + __Pyx_INCREF(__pyx_t_10); + __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL}; - __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __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_9)) __PYX_ERR(1, 485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_astype); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - #endif + __pyx_t_9 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_9); + __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_9, ((PyObject *)(&PyFloat_Type))}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __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; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); } - __Pyx_DECREF_SET(__pyx_v_series, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_series, __pyx_t_6); + __pyx_t_6 = 0; } __pyx_L5:; - __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_args, __pyx_v_series); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 486, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_args, __pyx_v_series); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 503, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 487, __pyx_L1_error) + __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, 504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { - __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); - __pyx_t_5 = 0; - __pyx_t_6 = NULL; + __pyx_t_6 = __pyx_t_1; __Pyx_INCREF(__pyx_t_6); + __pyx_t_4 = 0; + __pyx_t_5 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 487, __pyx_L1_error) + __pyx_t_4 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 504, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { - if (likely(!__pyx_t_6)) { - if (likely(PyList_CheckExact(__pyx_t_3))) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_6))) { { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 487, __pyx_L1_error) + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 504, __pyx_L1_error) #endif - if (__pyx_t_5 >= __pyx_temp) break; + if (__pyx_t_4 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 487, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_6, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_4; } else { { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 487, __pyx_L1_error) + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 504, __pyx_L1_error) #endif - if (__pyx_t_5 >= __pyx_temp) break; + if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 487, __pyx_L1_error) + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_4)); #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_4); #endif + ++__pyx_t_4; } + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 504, __pyx_L1_error) } else { - __pyx_t_1 = __pyx_t_6(__pyx_t_3); + __pyx_t_1 = __pyx_t_5(__pyx_t_6); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 487, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 504, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } + __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__get_opt_input_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 488, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_opt_input}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 488, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_opt_input}; + __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); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_args, __pyx_v_value); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 489, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_args, __pyx_v_value); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 506, __pyx_L1_error) } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_func_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 492, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 492, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_func_object); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 509, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 492, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 509, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_results = __pyx_t_2; __pyx_t_2 = 0; - __pyx_t_7 = __Pyx_TypeCheck(__pyx_v_results, __pyx_ptype_5numpy_ndarray); + __pyx_t_7 = __Pyx_TypeCheck(__pyx_v_results, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray); if (__pyx_t_7) { - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_outputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 494, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 494, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __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; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 494, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 511, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_keys = __pyx_t_2; __pyx_t_2 = 0; @@ -56025,107 +46006,104 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __pyx_t_8 = (!__pyx_t_7); if (__pyx_t_8) { - __pyx_t_2 = PySequence_List(__pyx_v_keys); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 496, __pyx_L1_error) + __pyx_t_2 = PySequence_List(__pyx_v_keys); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 513, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF_SET(__pyx_v_keys, __pyx_t_2); __pyx_t_2 = 0; } - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 497, __pyx_L1_error) + __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_3 = __Pyx_GetItemInt(__pyx_v_keys, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 497, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (unlikely((PyObject_SetItem(__pyx_t_2, __pyx_t_3, __pyx_v_results) < 0))) __PYX_ERR(1, 497, __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; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L14; } /*else*/ { - __Pyx_INCREF(__pyx_int_0); - __pyx_t_3 = __pyx_int_0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 499, __pyx_L1_error) + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_t_6 = __pyx_mstate_global->__pyx_int_0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); - __pyx_t_5 = 0; - __pyx_t_6 = NULL; + __pyx_t_4 = 0; + __pyx_t_5 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 499, __pyx_L1_error) + __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 499, __pyx_L1_error) + __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 516, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; for (;;) { - if (likely(!__pyx_t_6)) { + if (likely(!__pyx_t_5)) { if (likely(PyList_CheckExact(__pyx_t_1))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 499, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 516, __pyx_L1_error) #endif - if (__pyx_t_5 >= __pyx_temp) break; + if (__pyx_t_4 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 499, __pyx_L1_error) - #else - __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 499, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - #endif + __pyx_t_2 = __Pyx_PyList_GetItemRefFast(__pyx_t_1, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 499, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 516, __pyx_L1_error) #endif - if (__pyx_t_5 >= __pyx_temp) break; + if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 499, __pyx_L1_error) + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4)); #else - __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 499, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); #endif + ++__pyx_t_4; } + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 516, __pyx_L1_error) } else { - __pyx_t_2 = __pyx_t_6(__pyx_t_1); + __pyx_t_2 = __pyx_t_5(__pyx_t_1); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 499, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 516, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_2); } + __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_output, __pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); - __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 499, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6); + __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); - __pyx_t_3 = __pyx_t_2; + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = __pyx_t_2; __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_results, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 500, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_results, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_outputs); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 500, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - if (unlikely((PyObject_SetItem(__pyx_t_9, __pyx_v_output, __pyx_t_2) < 0))) __PYX_ERR(1, 500, __pyx_L1_error) + if (unlikely((PyObject_SetItem(__pyx_t_9, __pyx_v_output, __pyx_t_2) < 0))) __PYX_ERR(2, 517, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_L14:; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_n_s_outputs_valid, Py_True) < 0) __PYX_ERR(1, 501, __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 */ @@ -56134,7 +46112,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("talib._ta_lib.Function.__call_function", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -56165,7 +46143,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value = {"__check_opt_input_value", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_39__check_opt_input_value, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_38__check_opt_input_value, "Function.__check_opt_input_value(self, input_name, value)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value = {"__check_opt_input_value", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_39__check_opt_input_value, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_38__check_opt_input_value}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_39__check_opt_input_value(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -56188,7 +46167,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__check_opt_input_value (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -56196,59 +46175,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_name,&__pyx_n_s_value,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 520, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 520, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 503, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_input_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 503, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, 1); __PYX_ERR(1, 503, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 503, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, 2); __PYX_ERR(1, 503, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__check_opt_input_value") < 0)) __PYX_ERR(1, 503, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 520, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 520, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 520, __pyx_L3_error) } __pyx_v_self = values[0]; __pyx_v_input_name = values[1]; @@ -56256,15 +46216,12 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 503, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 520, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.__check_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -56273,11 +46230,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(__pyx_self, __pyx_v_self, __pyx_v_input_name, __pyx_v_value); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -56292,20 +46246,25 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9[7]; + size_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__check_opt_input_value", 1); + __Pyx_RefNannySetupContext("__check_opt_input_value", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 504, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 504, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_input_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 504, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_input_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_n_s_type_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 504, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_type_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_type_ = __pyx_t_2; @@ -56313,22 +46272,22 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY __Pyx_INCREF(__pyx_v_type_); __pyx_t_2 = __pyx_v_type_; - __pyx_t_1 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_IntegerList); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 505, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_IntegerList); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 505, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 522, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 505, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 522, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __pyx_t_4 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_IntegerRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 505, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_IntegerRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 505, __pyx_L1_error) + __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 522, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 505, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 522, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __pyx_t_5; __pyx_L4_bool_binop_done:; @@ -56336,30 +46295,30 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY __pyx_t_5 = __pyx_t_3; if (__pyx_t_5) { - __Pyx_INCREF((PyObject *)(&PyInt_Type)); - __Pyx_DECREF_SET(__pyx_v_type_, ((PyObject *)(&PyInt_Type))); + __Pyx_INCREF((PyObject *)(&PyLong_Type)); + __Pyx_DECREF_SET(__pyx_v_type_, ((PyObject *)(&PyLong_Type))); goto __pyx_L3; } __Pyx_INCREF(__pyx_v_type_); __pyx_t_2 = __pyx_v_type_; - __pyx_t_1 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_RealList); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 507, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_RealList); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 507, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 524, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 507, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 524, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_3) { } else { __pyx_t_5 = __pyx_t_3; goto __pyx_L6_bool_binop_done; } - __pyx_t_4 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_RealRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 507, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_RealRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 507, __pyx_L1_error) + __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 524, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 507, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 524, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = __pyx_t_3; __pyx_L6_bool_binop_done:; @@ -56373,7 +46332,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY } __pyx_L3:; - __pyx_t_3 = PyObject_IsInstance(__pyx_v_value, __pyx_v_type_); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 510, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_value, __pyx_v_type_); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 527, __pyx_L1_error) if (__pyx_t_3) { __Pyx_XDECREF(__pyx_r); @@ -56386,32 +46345,46 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY __pyx_t_3 = (__pyx_v_value != Py_None); if (unlikely(__pyx_t_3)) { - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_type_, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v_input_name); - __Pyx_GIVEREF(__pyx_v_input_name); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_input_name)) __PYX_ERR(1, 515, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(1, 515, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_1)) __PYX_ERR(1, 515, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_1 = 0; - - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_parameter_value_for_s_ex, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = NULL; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 513, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __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_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_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_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_ERR(1, 513, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_10 = 1; + { + 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_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 530, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(2, 530, __pyx_L1_error) } @@ -56426,6 +46399,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("talib._ta_lib.Function.__check_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -56444,8 +46420,8 @@ PyObject *const *__pyx_args, 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, "\n Returns the user-set value if there is one, otherwise the default.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value = {"__get_opt_input_value", (PyCFunction)(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}; +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -56467,7 +46443,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get_opt_input_value (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -56475,61 +46451,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_name,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 535, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 535, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 518, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_input_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 518, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__get_opt_input_value", 1, 2, 2, 1); __PYX_ERR(1, 518, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__get_opt_input_value") < 0)) __PYX_ERR(1, 518, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 535, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 535, __pyx_L3_error) } __pyx_v_self = values[0]; __pyx_v_input_name = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__get_opt_input_value", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 518, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__get_opt_input_value", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 535, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.__get_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -56538,11 +46499,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(__pyx_self, __pyx_v_self, __pyx_v_input_name); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -56559,19 +46517,19 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(CYTH int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get_opt_input_value", 1); + __Pyx_RefNannySetupContext("__get_opt_input_value", 0); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 522, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_local = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 523, __pyx_L1_error) + __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, 540, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 523, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 540, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 523, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 540, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_value = __pyx_t_1; @@ -56580,12 +46538,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(CYTH __pyx_t_3 = (__pyx_v_value == Py_None); if (__pyx_t_3) { - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_n_s_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 525, __pyx_L1_error) + __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, 542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 525, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_s_default_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 525, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_default_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_1); @@ -56622,7 +46580,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_43__repr__ = {"__repr__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_43__repr__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_42__repr__, "Function.__repr__(self)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_43__repr__ = {"__repr__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_43__repr__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_42__repr__}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_43__repr__(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -56643,7 +46602,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -56651,47 +46610,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 545, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 528, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__repr__") < 0)) __PYX_ERR(1, 528, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 545, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__repr__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 528, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__repr__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 545, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -56700,11 +46651,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_42__repr__(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -56718,12 +46666,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_42__repr__(CYTHON_UNUSED PyO int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 1); + __Pyx_RefNannySetupContext("__repr__", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 529, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 546, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_kp_s_s_2, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 529, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_s_2, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 546, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; @@ -56752,7 +46700,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__ = {"__unicode__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_45__unicode__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_44__unicode__, "Function.__unicode__(self)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__ = {"__unicode__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_45__unicode__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_44__unicode__}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_45__unicode__(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -56773,7 +46722,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__unicode__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -56781,47 +46730,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 548, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 531, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__unicode__") < 0)) __PYX_ERR(1, 531, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 548, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__unicode__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 531, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__unicode__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 548, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.__unicode__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -56830,11 +46771,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -56845,39 +46783,24 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(CYTHON_UNUSED __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; + size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__unicode__", 1); + __Pyx_RefNannySetupContext("__unicode__", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 532, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 532, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __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); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } - __pyx_t_2 = __Pyx_PyObject_Unicode(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 532, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Unicode(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 549, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; @@ -56889,7 +46812,6 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(CYTHON_UNUSED __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("talib._ta_lib.Function.__unicode__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -56907,7 +46829,8 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_47__str__ = {"__str__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_47__str__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_46__str__, "Function.__str__(self)"); +static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_47__str__ = {"__str__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_47__str__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_46__str__}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_47__str__(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds @@ -56928,7 +46851,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -56936,47 +46859,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 551, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 534, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__str__") < 0)) __PYX_ERR(1, 534, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 551, __pyx_L3_error) } __pyx_v_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__str__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 534, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__str__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 551, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.Function.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -56985,11 +46900,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_46__str__(__pyx_self, __pyx_v_self); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -57002,45 +46914,44 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_46__str__(CYTHON_UNUSED PyOb PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; + size_t __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__str__", 1); + __Pyx_RefNannySetupContext("__str__", 0); __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_get_defaults_and_docs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 535, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 535, __pyx_L1_error) + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_defaults_and_docs); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 552, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_5 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4}; + __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(1, 535, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 552, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 535, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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_2; - __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; @@ -57060,23 +46971,23 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_46__str__(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_343_ta_getGroupTable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_342_ta_getGroupTable, "\n Returns the list of available TALIB function group names. *slow*\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_343_ta_getGroupTable = {"_ta_getGroupTable", (PyCFunction)__pyx_pw_5talib_7_ta_lib_343_ta_getGroupTable, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_342_ta_getGroupTable}; -static PyObject *__pyx_pw_5talib_7_ta_lib_343_ta_getGroupTable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { +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()\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; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_getGroupTable (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(__pyx_self); + __pyx_r = __pyx_pf_5talib_7_ta_lib_348_ta_getGroupTable(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(CYTHON_UNUSED PyObject *__pyx_self) { +static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getGroupTable(CYTHON_UNUSED PyObject *__pyx_self) { TA_StringTable *__pyx_v_table; PyObject *__pyx_v_groups = NULL; unsigned int __pyx_v_i; @@ -57090,13 +47001,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(CYTHON_UNUSED PyO int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_getGroupTable", 1); + __Pyx_RefNannySetupContext("_ta_getGroupTable", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GroupTableAlloc, TA_GroupTableAlloc((&__pyx_v_table)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 553, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GroupTableAlloc, TA_GroupTableAlloc((&__pyx_v_table)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 570, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 554, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_groups = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; @@ -57106,13 +47017,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(CYTHON_UNUSED PyO for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - __pyx_t_1 = __Pyx_PyBytes_FromString((*(&(__pyx_v_table->string[__pyx_v_i])))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBytes_FromString((*(&(__pyx_v_table->string[__pyx_v_i])))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_groups, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 556, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_groups, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 573, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GroupTableFree, TA_GroupTableFree(__pyx_v_table), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 557, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GroupTableFree, TA_GroupTableFree(__pyx_v_table), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -57136,16 +47047,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_345_ta_getFuncTable(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_351_ta_getFuncTable(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_344_ta_getFuncTable, "\n Returns a list of the functions for the specified group name. *slow*\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_345_ta_getFuncTable = {"_ta_getFuncTable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_345_ta_getFuncTable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_344_ta_getFuncTable}; -static PyObject *__pyx_pw_5talib_7_ta_lib_345_ta_getFuncTable(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -57165,7 +47076,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_getFuncTable (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -57173,66 +47084,55 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_group,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 577, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_group)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 560, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_getFuncTable") < 0)) __PYX_ERR(1, 560, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 577, __pyx_L3_error) } - __pyx_v_group = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_group) && PyErr_Occurred())) __PYX_ERR(1, 560, __pyx_L3_error) + __pyx_v_group = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_group) && PyErr_Occurred())) __PYX_ERR(2, 577, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_getFuncTable", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 560, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_getFuncTable", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 577, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_getFuncTable", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(__pyx_self, __pyx_v_group); + __pyx_r = __pyx_pf_5talib_7_ta_lib_350_ta_getFuncTable(__pyx_self, __pyx_v_group); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_group) { +static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getFuncTable(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_group) { TA_StringTable *__pyx_v_table; PyObject *__pyx_v_functions = NULL; unsigned int __pyx_v_i; @@ -57246,13 +47146,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(CYTHON_UNUSED PyOb int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_getFuncTable", 1); + __Pyx_RefNannySetupContext("_ta_getFuncTable", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_FuncTableAlloc, TA_FuncTableAlloc(__pyx_v_group, (&__pyx_v_table)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 565, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_FuncTableAlloc, TA_FuncTableAlloc(__pyx_v_group, (&__pyx_v_table)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 582, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 566, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_functions = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; @@ -57262,13 +47162,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(CYTHON_UNUSED PyOb for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - __pyx_t_1 = __Pyx_PyBytes_FromString((*(&(__pyx_v_table->string[__pyx_v_i])))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 568, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBytes_FromString((*(&(__pyx_v_table->string[__pyx_v_i])))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_functions, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 568, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_functions, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 585, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_FuncTableFree, TA_FuncTableFree(__pyx_v_table), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_FuncTableFree, TA_FuncTableFree(__pyx_v_table), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -57292,16 +47192,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_347__get_flags(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_353__get_flags(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_346__get_flags, "\n TA-LIB provides hints for multiple flags as a bitwise-ORed int.\n This function returns the flags from flag found in the provided\n flags_lookup_dict.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_347__get_flags = {"__get_flags", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_347__get_flags, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_346__get_flags}; -static PyObject *__pyx_pw_5talib_7_ta_lib_347__get_flags(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -57322,7 +47222,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get_flags (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -57330,85 +47230,72 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,&__pyx_n_s_flags_lookup_dict,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 589, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 589, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flag)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 572, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags_lookup_dict)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 572, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__get_flags", 1, 2, 2, 1); __PYX_ERR(1, 572, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__get_flags") < 0)) __PYX_ERR(1, 572, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 589, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 589, __pyx_L3_error) } - __pyx_v_flag = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_flag == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 572, __pyx_L3_error) + __pyx_v_flag = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_flag == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 589, __pyx_L3_error) __pyx_v_flags_lookup_dict = ((PyObject*)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__get_flags", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 572, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__get_flags", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 589, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.__get_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_flags_lookup_dict), (&PyDict_Type), 1, "flags_lookup_dict", 1))) __PYX_ERR(1, 572, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_346__get_flags(__pyx_self, __pyx_v_flag, __pyx_v_flags_lookup_dict); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_flags_lookup_dict), (&PyDict_Type), 1, "flags_lookup_dict", 1))) __PYX_ERR(2, 589, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_352__get_flags(__pyx_self, __pyx_v_flag, __pyx_v_flags_lookup_dict); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flag, PyObject *__pyx_v_flags_lookup_dict) { +static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flag, PyObject *__pyx_v_flags_lookup_dict) { PyObject *__pyx_v_value_range = NULL; PyObject *__pyx_v_min_int = NULL; PyObject *__pyx_v_max_int = NULL; @@ -57422,20 +47309,20 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_7 = NULL; + 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; - __Pyx_RefNannySetupContext("__get_flags", 1); + __Pyx_RefNannySetupContext("__get_flags", 0); if (unlikely(__pyx_v_flags_lookup_dict == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); - __PYX_ERR(1, 578, __pyx_L1_error) + __PYX_ERR(2, 595, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyDict_Keys(__pyx_v_flags_lookup_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 578, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_Keys(__pyx_v_flags_lookup_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_value_range = __pyx_t_1; __pyx_t_1 = 0; @@ -57444,83 +47331,95 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject __pyx_t_3 = (!__pyx_t_2); if (__pyx_t_3) { - __pyx_t_1 = PySequence_List(__pyx_v_value_range); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 580, __pyx_L1_error) + __pyx_t_1 = PySequence_List(__pyx_v_value_range); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 597, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_value_range, __pyx_t_1); __pyx_t_1 = 0; } - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 581, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 581, __pyx_L1_error) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_min, __pyx_v_value_range); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 581, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_log); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_value_range}; + __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; + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_8 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_7 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_4, __pyx_int_2}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 581, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_mstate_global->__pyx_int_2}; + __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; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); } - __pyx_t_5 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 581, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_min_int = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_v_min_int = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_math); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 582, __pyx_L1_error) + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __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_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_max, __pyx_v_value_range); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = NULL; + __pyx_t_8 = 1; + { + 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_8 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; - } + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_1, __pyx_int_2}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_mstate_global->__pyx_int_2}; + __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; + if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); } - __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 582, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_6); 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_v_max_int = __pyx_t_4; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_max_int = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = (__pyx_v_flag < 1); @@ -57529,15 +47428,15 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject __pyx_t_3 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_flag); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 585, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_flag); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyNumber_PowerOf2(__pyx_int_2, __pyx_v_max_int, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 585, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 585, __pyx_L1_error) + __pyx_t_6 = PyNumber_Power(__pyx_mstate_global->__pyx_int_2, __pyx_v_max_int, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 602, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 602, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 585, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __pyx_t_2; __pyx_L5_bool_binop_done:; if (__pyx_t_3) { @@ -57548,108 +47447,72 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject } - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_ret = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_v_max_int, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 592, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_v_min_int); - __Pyx_GIVEREF(__pyx_v_min_int); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_min_int)) __PYX_ERR(1, 592, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_xrange, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { - __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); - __pyx_t_8 = 0; - __pyx_t_9 = NULL; - } else { - __pyx_t_8 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 592, __pyx_L1_error) + __pyx_v_ret = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + __pyx_t_6 = NULL; + __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_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_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 592, __pyx_L1_error) } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __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_9)) { - if (likely(PyList_CheckExact(__pyx_t_5))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 592, __pyx_L1_error) - #endif - if (__pyx_t_8 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_8); __Pyx_INCREF(__pyx_t_1); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(1, 592, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 592, __pyx_L1_error) - #endif - if (__pyx_t_8 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_8); __Pyx_INCREF(__pyx_t_1); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(1, 592, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif - } - } else { - __pyx_t_1 = __pyx_t_9(__pyx_t_5); - if (unlikely(!__pyx_t_1)) { + { + __pyx_t_5 = __pyx_t_9(__pyx_t_4); + if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 592, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 609, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); - __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_5); + 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_1 = __Pyx_PyNumber_PowerOf2(__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 593, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_flag); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 593, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = PyNumber_And(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 593, __pyx_L1_error) + __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_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_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 593, __pyx_L1_error) + __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_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(1, 594, __pyx_L1_error) + __PYX_ERR(2, 611, __pyx_L1_error) } - __pyx_t_6 = __Pyx_PyNumber_PowerOf2(__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 594, __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_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_t_4 = __Pyx_PyDict_GetItem(__pyx_v_flags_lookup_dict, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 594, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __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; - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_ret, __pyx_t_4); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 594, __pyx_L1_error) - __Pyx_DECREF(__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_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ret); @@ -57663,6 +47526,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("talib._ta_lib.__get_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -57678,16 +47542,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_349_ta_getFuncInfo(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_355_ta_getFuncInfo(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_348_ta_getFuncInfo, "\n Returns the info dict for the function. It has the following keys: name,\n group, help, flags, num_inputs, num_opt_inputs and num_outputs.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_349_ta_getFuncInfo = {"_ta_getFuncInfo", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_349_ta_getFuncInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_348_ta_getFuncInfo}; -static PyObject *__pyx_pw_5talib_7_ta_lib_349_ta_getFuncInfo(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -57707,7 +47571,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_getFuncInfo (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -57715,66 +47579,55 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function_name,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 648, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_function_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 631, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_getFuncInfo") < 0)) __PYX_ERR(1, 631, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 648, __pyx_L3_error) } - __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(1, 631, __pyx_L3_error) + __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(2, 648, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_getFuncInfo", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 631, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_getFuncInfo", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 648, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_getFuncInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_348_ta_getFuncInfo(__pyx_self, __pyx_v_function_name); + __pyx_r = __pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(__pyx_self, __pyx_v_function_name); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getFuncInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name) { +static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name) { TA_FuncInfo const *__pyx_v_info; TA_RetCode __pyx_v_retCode; PyObject *__pyx_r = NULL; @@ -57785,170 +47638,187 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getFuncInfo(CYTHON_UNUSED PyObj PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; + size_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_getFuncInfo", 1); + __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 *)NULL) && PyErr_Occurred())) __PYX_ERR(1, 637, __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_n_s_TA_GetFuncInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 638, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 641, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 641, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 641, __pyx_L1_error) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_info->name); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 658, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6}; + __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(1, 641, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_name, __pyx_t_3) < 0) __PYX_ERR(1, 641, __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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 642, __pyx_L1_error) + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->group); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 659, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->group); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 642, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; + __pyx_t_7 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 642, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __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_n_s_group, __pyx_t_3) < 0) __PYX_ERR(1, 641, __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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 643, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->hint); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 643, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->hint); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; + __pyx_t_7 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; - } + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __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; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 643, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); __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_n_s_display_name, __pyx_t_3) < 0) __PYX_ERR(1, 641, __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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_get_flags); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 644, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyInt_From_TA_FuncFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 644, __pyx_L1_error) + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_get_flags); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_TA_FUNC_FLAGS); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 644, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyLong_From_TA_FuncFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = NULL; - __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_TA_FUNC_FLAGS); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_5, __pyx_t_6}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_8}; + __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; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 644, __pyx_L1_error) + __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, 661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_function_flags, __pyx_t_3) < 0) __PYX_ERR(1, 641, __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_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_info->nbInput); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 645, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyInt_Type)), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 645, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __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_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; + 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) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_inputs, __pyx_t_4) < 0) __PYX_ERR(1, 641, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_info->nbOptInput); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 646, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyInt_Type)), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 646, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_opt_inputs, __pyx_t_3) < 0) __PYX_ERR(1, 641, __pyx_L1_error) + __pyx_t_8 = NULL; + __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((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; + 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) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_info->nbOutput); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 647, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyInt_Type)), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 647, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __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_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; + 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) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_outputs, __pyx_t_4) < 0) __PYX_ERR(1, 641, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; @@ -57972,16 +47842,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getFuncInfo(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_351_ta_getInputParameterInfo(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_357_ta_getInputParameterInfo(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_350_ta_getInputParameterInfo, "\n Returns the function's input info dict for the given index. It has two\n keys: name and flags.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_351_ta_getInputParameterInfo = {"_ta_getInputParameterInfo", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_351_ta_getInputParameterInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_350_ta_getInputParameterInfo}; -static PyObject *__pyx_pw_5talib_7_ta_lib_351_ta_getInputParameterInfo(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -58002,7 +47872,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_getInputParameterInfo (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -58010,80 +47880,62 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function_name,&__pyx_n_s_idx,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 667, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 667, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_function_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_idx)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("_ta_getInputParameterInfo", 1, 2, 2, 1); __PYX_ERR(1, 650, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_getInputParameterInfo") < 0)) __PYX_ERR(1, 650, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 667, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 667, __pyx_L3_error) } - __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L3_error) - __pyx_v_idx = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L3_error) + __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(2, 667, __pyx_L3_error) + __pyx_v_idx = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 667, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_getInputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 650, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_getInputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 667, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_getInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx); + __pyx_r = __pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) { +static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) { TA_InputParameterInfo const *__pyx_v_info; TA_RetCode __pyx_v_retCode; PyObject *__pyx_v_name = NULL; @@ -58094,7 +47946,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(CYTHON_UN PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + size_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; @@ -58102,139 +47954,123 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(CYTHON_UN int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_getInputParameterInfo", 1); + __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 *)NULL) && PyErr_Occurred())) __PYX_ERR(1, 656, __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_n_s_TA_GetInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 657, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 659, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 659, __pyx_L1_error) + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - __pyx_t_6 = 0; + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_6 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; + __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(1, 659, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_name = __pyx_t_2; __pyx_t_2 = 0; - __pyx_t_7 = PyObject_Length(__pyx_n_s_in); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 660, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 660, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_lower); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 660, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; + __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_in); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 677, __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, 677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_4); __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } - } - #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __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) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_real, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 661, __pyx_L1_error) + __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_real, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 678, __pyx_L1_error) if (__pyx_t_8) { - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_replace); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 662, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_mstate_global->__pyx_n_u_replace); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 662, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[0], NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_4); - __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_5); + __pyx_t_5 = 0; goto __pyx_L3; } - __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_price, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 663, __pyx_L1_error) + __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_price, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 680, __pyx_L1_error) if (__pyx_t_8) { - __Pyx_INCREF(__pyx_n_s_prices); - __Pyx_DECREF_SET(__pyx_v_name, __pyx_n_s_prices); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_prices); + __Pyx_DECREF_SET(__pyx_v_name, __pyx_mstate_global->__pyx_n_u_prices); } __pyx_L3:; __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 667, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_name, __pyx_v_name) < 0) __PYX_ERR(1, 667, __pyx_L1_error) + __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) - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_get_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 668, __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) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyInt_From_TA_InputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 668, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_TA_INPUT_FLAGS); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 668, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyLong_From_TA_InputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = NULL; - __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_TA_INPUT_FLAGS); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_6 = 1; - } + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_5, __pyx_t_9}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_9, __pyx_t_10}; + __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; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 668, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); } - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_price_series, __pyx_t_2) < 0) __PYX_ERR(1, 667, __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_4; - __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; goto __pyx_L0; @@ -58257,16 +48093,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(CYTHON_UN /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_353_ta_getOptInputParameterInfo(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_359_ta_getOptInputParameterInfo(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_352_ta_getOptInputParameterInfo, "\n Returns the function's opt_input info dict for the given index. It has the\n following keys: name, display_name, type, help, default_value and value.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_353_ta_getOptInputParameterInfo = {"_ta_getOptInputParameterInfo", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_353_ta_getOptInputParameterInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_352_ta_getOptInputParameterInfo}; -static PyObject *__pyx_pw_5talib_7_ta_lib_353_ta_getOptInputParameterInfo(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -58287,7 +48123,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_getOptInputParameterInfo (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -58295,80 +48131,62 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function_name,&__pyx_n_s_idx,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 688, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 688, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_function_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 671, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_idx)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 671, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("_ta_getOptInputParameterInfo", 1, 2, 2, 1); __PYX_ERR(1, 671, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_getOptInputParameterInfo") < 0)) __PYX_ERR(1, 671, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 688, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 688, __pyx_L3_error) } - __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(1, 671, __pyx_L3_error) - __pyx_v_idx = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 671, __pyx_L3_error) + __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(2, 688, __pyx_L3_error) + __pyx_v_idx = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 688, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_getOptInputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 671, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_getOptInputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 688, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_getOptInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx); + __pyx_r = __pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) { +static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) { TA_OptInputParameterInfo const *__pyx_v_info; TA_RetCode __pyx_v_retCode; PyObject *__pyx_v_name = NULL; @@ -58380,184 +48198,155 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(CYTHON PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + size_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; - int __pyx_t_9; - PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_getOptInputParameterInfo", 1); + __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 *)NULL) && PyErr_Occurred())) __PYX_ERR(1, 677, __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_n_s_TA_GetOptInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 678, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 680, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 680, __pyx_L1_error) + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - __pyx_t_6 = 0; + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 697, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_6 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; + __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(1, 680, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_name = __pyx_t_2; __pyx_t_2 = 0; - __pyx_t_7 = PyObject_Length(__pyx_n_s_optIn); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 681, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 681, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_lower); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 681, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; + __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_optIn); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 698, __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, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_4); __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } - } - #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 681, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __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) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_info->defaultValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 682, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_v_default_value = __pyx_t_2; - __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_PyInt_RemainderObjC(__pyx_v_default_value, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 683, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = (__Pyx_PyInt_BoolEqObjC(__pyx_t_2, __pyx_int_0, 0, 0)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(1, 683, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (__pyx_t_9) { - } else { - __pyx_t_8 = __pyx_t_9; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_9 = (__pyx_v_info->type > 1); - __pyx_t_8 = __pyx_t_9; - __pyx_L4_bool_binop_done:; + __pyx_t_8 = (__pyx_v_info->type > 1); if (__pyx_t_8) { - - __pyx_t_2 = __Pyx_PyNumber_Int(__pyx_v_default_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 684, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF_SET(__pyx_v_default_value, __pyx_t_2); - __pyx_t_2 = 0; - + __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_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(1, 687, __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_n_s_name, __pyx_v_name) < 0) __PYX_ERR(1, 687, __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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 688, __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, 703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->displayName); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 688, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = NULL; - __pyx_t_6 = 0; + __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))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_6 = 1; - } + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_5}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 688, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + 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_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 703, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); } - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_display_name, __pyx_t_4) < 0) __PYX_ERR(1, 687, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - __pyx_t_4 = __Pyx_PyInt_From_TA_OptInputParameterType(__pyx_v_info->type); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 689, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_type_2, __pyx_t_4) < 0) __PYX_ERR(1, 687, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 690, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->hint); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 690, __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); - __pyx_t_10 = NULL; - __pyx_t_6 = 0; + 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_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_3))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_6 = 1; - } + 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_9); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_9, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_5}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 690, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __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_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_n_s_help, __pyx_t_4) < 0) __PYX_ERR(1, 687, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + 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; - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_default_value, __pyx_v_default_value) < 0) __PYX_ERR(1, 687, __pyx_L1_error) + 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_n_s_value, Py_None) < 0) __PYX_ERR(1, 687, __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; @@ -58569,7 +48358,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(CYTHON __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("talib._ta_lib._ta_getOptInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -58582,16 +48371,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(CYTHON /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_355_ta_getOutputParameterInfo(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_361_ta_getOutputParameterInfo(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_354_ta_getOutputParameterInfo, "\n Returns the function's output info dict for the given index. It has two\n keys: name and flags.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_355_ta_getOutputParameterInfo = {"_ta_getOutputParameterInfo", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_355_ta_getOutputParameterInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_354_ta_getOutputParameterInfo}; -static PyObject *__pyx_pw_5talib_7_ta_lib_355_ta_getOutputParameterInfo(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -58612,7 +48401,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_getOutputParameterInfo (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -58620,80 +48409,62 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function_name,&__pyx_n_s_idx,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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, 710, __pyx_L3_error) + if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 710, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + 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; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_function_name)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 695, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_idx)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 695, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, 1); __PYX_ERR(1, 695, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_ta_getOutputParameterInfo") < 0)) __PYX_ERR(1, 695, __pyx_L3_error) + const Py_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, 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, 710, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + 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, 710, __pyx_L3_error) } - __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(1, 695, __pyx_L3_error) - __pyx_v_idx = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 695, __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(1, 695, __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:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._ta_getOutputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx); + __pyx_r = __pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) { +static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) { TA_OutputParameterInfo const *__pyx_v_info; TA_RetCode __pyx_v_retCode; PyObject *__pyx_v_name = NULL; @@ -58704,7 +48475,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_U PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + size_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; int __pyx_t_9; @@ -58714,77 +48485,62 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_U int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_ta_getOutputParameterInfo", 1); + __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 *)NULL) && PyErr_Occurred())) __PYX_ERR(1, 701, __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_n_s_TA_GetOutputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 702, __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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 704, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 704, __pyx_L1_error) + __pyx_t_3 = NULL; + __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 = NULL; - __pyx_t_6 = 0; + __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 - if (unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_6 = 1; - } + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; + __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(1, 704, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_name = __pyx_t_2; __pyx_t_2 = 0; - __pyx_t_7 = PyObject_Length(__pyx_n_s_out); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 705, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 705, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_lower); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 705, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; + __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; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } - } - #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 705, __pyx_L1_error) + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __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, 720, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_real, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(1, 707, __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; @@ -58792,19 +48548,19 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_U } __Pyx_INCREF(__pyx_v_name); __pyx_t_2 = __pyx_v_name; - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_real, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(1, 707, __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_PyString_Equals(__pyx_t_2, __pyx_n_s_real0, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(1, 707, __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_PyString_Equals(__pyx_t_2, __pyx_n_s_real1, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(1, 707, __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; @@ -58813,8 +48569,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_U __pyx_L4_bool_binop_done:; if (__pyx_t_8) { - __pyx_t_7 = PyObject_Length(__pyx_n_s_real); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 708, __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(1, 708, __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; @@ -58823,42 +48579,41 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_U __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 711, __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_n_s_name, __pyx_v_name) < 0) __PYX_ERR(1, 711, __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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_get_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 712, __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, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyInt_From_TA_OutputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 712, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_TA_OUTPUT_FLAGS); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 712, __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_t_12 = NULL; - __pyx_t_6 = 0; + __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 if (unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_12)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_12); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_6 = 1; - } + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_12, __pyx_t_5, __pyx_t_11}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_11, __pyx_t_12}; + __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; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 712, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __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, 727, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); } - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_flags, __pyx_t_4) < 0) __PYX_ERR(1, 711, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + 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; goto __pyx_L0; @@ -58883,16 +48638,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_U /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_357_get_defaults_and_docs(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_363_get_defaults_and_docs(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_356_get_defaults_and_docs, "\n Returns a tuple with two outputs: defaults, a dict of parameter defaults,\n and documentation, a formatted docstring for the function.\n .. Note: func_info should come from Function.info, *not* _ta_getFuncInfo.\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_357_get_defaults_and_docs = {"_get_defaults_and_docs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_357_get_defaults_and_docs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_356_get_defaults_and_docs}; -static PyObject *__pyx_pw_5talib_7_ta_lib_357_get_defaults_and_docs(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -58912,7 +48667,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get_defaults_and_docs (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -58920,66 +48675,55 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_func_info,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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, 730, __pyx_L3_error) + if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + 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; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_func_info)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 715, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_get_defaults_and_docs") < 0)) __PYX_ERR(1, 715, __pyx_L3_error) + const Py_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, 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, 730, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + 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(1, 715, __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:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib._get_defaults_and_docs", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_5talib_7_ta_lib_356_get_defaults_and_docs(__pyx_self, __pyx_v_func_info); + __pyx_r = __pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(__pyx_self, __pyx_v_func_info); /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_356_get_defaults_and_docs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_func_info) { +static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_func_info) { PyObject *__pyx_v_defaults = NULL; PyObject *__pyx_v_func_line = NULL; PyObject *__pyx_v_func_args = NULL; @@ -59002,112 +48746,111 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_get_defaults_and_docs(CYTHON_UNUSE int __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_9[4]; PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11[5]; + PyObject *__pyx_t_12 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_get_defaults_and_docs", 1); + __Pyx_RefNannySetupContext("_get_defaults_and_docs", 0); - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 721, __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_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 722, __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(1, 722, __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)) __PYX_ERR(1, 722, __pyx_L1_error); - __Pyx_INCREF(__pyx_kp_s__9); - __Pyx_GIVEREF(__pyx_kp_s__9); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_kp_s__9)) __PYX_ERR(1, 722, __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, 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(1, 723, __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_kp_s_input_arrays_2); - __Pyx_GIVEREF(__pyx_kp_s_input_arrays_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_kp_s_input_arrays_2)) __PYX_ERR(1, 723, __pyx_L1_error); + __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, 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(1, 724, __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_PyString_FormatSafe(__pyx_kp_s_display_name_s_group_s, __pyx_v_func_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 725, __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(1, 725, __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_n_s_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 727, __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_kp_s_Inputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 728, __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(1, 729, __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 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 729, __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)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 729, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 744, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 729, __pyx_L1_error) - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 729, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif + __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_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 729, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 744, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 729, __pyx_L1_error) + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4)); #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 729, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); #endif + ++__pyx_t_4; } + 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 (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 729, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 744, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_1); } + __Pyx_GOTREF(__pyx_t_1); __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(1, 730, __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; @@ -59116,37 +48859,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_get_defaults_and_docs(CYTHON_UNUSE __pyx_t_7 = (!__pyx_t_6); if (__pyx_t_7) { - __Pyx_INCREF(__pyx_kp_s_any_ndarray); - __Pyx_DECREF_SET(__pyx_v_value, __pyx_kp_s_any_ndarray); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_any_ndarray); + __Pyx_DECREF_SET(__pyx_v_value, __pyx_mstate_global->__pyx_kp_u_any_ndarray); } - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 733, __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_INCREF(__pyx_v_input_name); - __Pyx_GIVEREF(__pyx_v_input_name); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_input_name)) __PYX_ERR(1, 733, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_value); - __Pyx_GIVEREF(__pyx_v_value); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_value)) __PYX_ERR(1, 733, __pyx_L1_error); - __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 733, __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, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); __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(1, 733, __pyx_L1_error) __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, 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_n_s_parameters); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 735, __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(1, 736, __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_kp_s_Parameters); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 737, __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) } @@ -59155,232 +48900,233 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_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(1, 738, __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 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 738, __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)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 738, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 753, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_8); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 738, __pyx_L1_error) - #else - __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 738, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - #endif + __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_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 738, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 753, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_8); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 738, __pyx_L1_error) + __pyx_t_10 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4)); #else - __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 738, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); #endif + ++__pyx_t_4; } + if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 753, __pyx_L1_error) } else { - __pyx_t_8 = __pyx_t_5(__pyx_t_2); - if (unlikely(!__pyx_t_8)) { + __pyx_t_10 = __pyx_t_5(__pyx_t_2); + if (unlikely(!__pyx_t_10)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 738, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 753, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_8); } - __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_8); - __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_10); + __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_10); + __pyx_t_10 = 0; - __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 739, __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, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __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_INCREF(__pyx_v_param); - __Pyx_GIVEREF(__pyx_v_param); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_param)) __PYX_ERR(1, 739, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_8); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_8)) __PYX_ERR(1, 739, __pyx_L1_error); - __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 739, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u__7; + __pyx_t_9[1] = __pyx_t_10; + __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, 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(1, 739, __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_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 740, __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 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 740, __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_INCREF(__pyx_v_param); - __Pyx_GIVEREF(__pyx_v_param); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_param)) __PYX_ERR(1, 740, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_8); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_8)) __PYX_ERR(1, 740, __pyx_L1_error); - __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_s_2, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 740, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __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_3 = __Pyx_PyList_Append(__pyx_v_func_args, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 740, __pyx_L1_error) + __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u__8; + __pyx_t_11[1] = __pyx_t_8; + __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u__9; + __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, 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, 755, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 741, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (unlikely((PyDict_SetItem(__pyx_v_defaults, __pyx_v_param, __pyx_t_8) < 0))) __PYX_ERR(1, 741, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __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, 756, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_v_param, __pyx_n_s_matype, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 742, __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_8 = __Pyx_GetItemInt_List(__pyx_v_docs, -1L, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 743, __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_t_9 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 743, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyString_FormatSafe(__pyx_kp_s_s_3, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __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, 758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = PyList_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); + __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, 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, 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, 758, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_8); - if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_t_8)) __PYX_ERR(1, 743, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_9); - if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_9)) __PYX_ERR(1, 743, __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_9 = 0; - __pyx_t_9 = __Pyx_PyString_Join(__pyx_kp_s__10, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely((__Pyx_SetItemInt(__pyx_v_docs, -1L, __pyx_t_9, long, 1, __Pyx_PyInt_From_long, 1, 1, 1) < 0))) __PYX_ERR(1, 743, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __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, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(2, 758, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_n_s_output_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 745, __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_kp_s_Outputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 746, __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(1, 747, __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 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 747, __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)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 762, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_9 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_9); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) - #else - __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 747, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - #endif + __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_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 762, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_9); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) + __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4)); #else - __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 747, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); #endif + ++__pyx_t_4; } + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 762, __pyx_L1_error) } else { - __pyx_t_9 = __pyx_t_5(__pyx_t_2); - if (unlikely(!__pyx_t_9)) { + __pyx_t_8 = __pyx_t_5(__pyx_t_2); + if (unlikely(!__pyx_t_8)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 747, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 762, __pyx_L1_error) + PyErr_Clear(); } break; } - __Pyx_GOTREF(__pyx_t_9); } - __Pyx_XDECREF_SET(__pyx_v_output, __pyx_t_9); - __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_output, __pyx_t_8); + __pyx_t_8 = 0; - __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_v_output, __pyx_n_s_integer, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 748, __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_kp_s_integer_values_are_100_0_or_100); - __Pyx_DECREF_SET(__pyx_v_output, __pyx_kp_s_integer_values_are_100_0_or_100); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_integer_values_are_100_0_or_100); + __Pyx_DECREF_SET(__pyx_v_output, __pyx_mstate_global->__pyx_kp_u_integer_values_are_100_0_or_100); } - __pyx_t_9 = __Pyx_PyString_FormatSafe(__pyx_kp_s_s_4, __pyx_v_output); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 750, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_9); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __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, 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 = __Pyx_PyString_Join(__pyx_kp_s__7, __pyx_v_func_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 752, __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(1, 752, __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_kp_s__11); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 753, __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 = __Pyx_PyString_Join(__pyx_kp_s__6, __pyx_v_func_line); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 754, __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(1, 754, __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 = __Pyx_PyString_Join(__pyx_kp_s__12, __pyx_v_docs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 755, __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(1, 756, __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)) __PYX_ERR(1, 756, __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)) __PYX_ERR(1, 756, __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; @@ -59391,8 +49137,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_get_defaults_and_docs(CYTHON_UNUSE __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_12); __Pyx_AddTraceback("talib._ta_lib._get_defaults_and_docs", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -59422,9 +49168,9 @@ static TA_FuncHandle const *__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(char *__p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__ta_getFuncHandle", 1); + __Pyx_RefNannySetupContext("__ta_getFuncHandle", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GetFuncHandle, TA_GetFuncHandle(__pyx_v_function_name, (&__pyx_v_handle)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 772, __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; @@ -59453,12 +49199,12 @@ static TA_ParamHolder *__pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(char *__pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__ta_paramHolderAlloc", 1); + __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 *)NULL) && PyErr_Occurred())) __PYX_ERR(1, 780, __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_n_s_TA_ParamHolderAlloc, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 781, __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; @@ -59484,9 +49230,9 @@ static int __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(TA_ParamHolder *__pyx_v_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__ta_paramHolderFree", 1); + __Pyx_RefNannySetupContext("__ta_paramHolderFree", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ParamHolderFree, TA_ParamHolderFree(__pyx_v_params), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 789, __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; @@ -59512,11 +49258,11 @@ static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(TA_ParamHolder * int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__ta_setOptInputParamInteger", 1); + __Pyx_RefNannySetupContext("__ta_setOptInputParamInteger", 0); __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_n_s_TA_SetOptInputParamInteger, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 793, __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; @@ -59542,11 +49288,11 @@ static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(TA_ParamHolder *__p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__ta_setOptInputParamReal", 1); + __Pyx_RefNannySetupContext("__ta_setOptInputParamReal", 0); __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_n_s_TA_SetOptInputParamReal, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 797, __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; @@ -59573,11 +49319,11 @@ static int __pyx_f_5talib_7_ta_lib___ta_getLookback(TA_ParamHolder *__pyx_v_hold int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__ta_getLookback", 1); + __Pyx_RefNannySetupContext("__ta_getLookback", 0); __pyx_v_retCode = TA_GetLookback(__pyx_v_holder, (&__pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GetLookback, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 802, __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; @@ -59597,16 +49343,250 @@ static int __pyx_f_5talib_7_ta_lib___ta_getLookback(TA_ParamHolder *__pyx_v_hold /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_359stream_ACOS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_365stream_ACCBANDS(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + int __pyx_v_timeperiod; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stream_ACCBANDS (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 9, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 9, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 9, __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(5, 9, __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, "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) } + } + } else { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 9, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 9, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 9, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 9, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_high = ((PyArrayObject *)values[0]); + __pyx_v_low = ((PyArrayObject *)values[1]); + __pyx_v_close = ((PyArrayObject *)values[2]); + if (values[3]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 11, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stream_ACCBANDS", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 9, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.stream_ACCBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 11, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 11, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 11, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_364stream_ACCBANDS(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ACCBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { + npy_intp __pyx_v_length; + TA_RetCode __pyx_v_retCode; + double *__pyx_v_high_data; + double *__pyx_v_low_data; + double *__pyx_v_close_data; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + double __pyx_v_outrealupperband; + double __pyx_v_outrealmiddleband; + double __pyx_v_outreallowerband; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_intp __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("stream_ACCBANDS", 0); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __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)-1L))) __PYX_ERR(5, 42, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; + + __pyx_v_outrealupperband = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_outrealmiddleband = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_outreallowerband = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_retCode = TA_ACCBANDS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outrealupperband), (&__pyx_v_outrealmiddleband), (&__pyx_v_outreallowerband)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ACCBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outrealupperband); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outrealmiddleband); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outreallowerband); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 48, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(5, 48, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4) != (0)) __PYX_ERR(5, 48, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("talib._ta_lib.stream_ACCBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_367stream_ACOS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_358stream_ACOS, " ACOS(real)\n\n Vector Trigonometric ACos (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_359stream_ACOS = {"stream_ACOS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_359stream_ACOS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_358stream_ACOS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_359stream_ACOS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -59626,7 +49606,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ACOS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -59634,71 +49614,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 50, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 9, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ACOS") < 0)) __PYX_ERR(4, 9, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 50, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ACOS", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 9, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ACOS", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 50, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ACOS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 11, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_358stream_ACOS(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 52, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_366stream_ACOS(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_358stream_ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -59708,35 +49682,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_358stream_ACOS(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_ACOS", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 28, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 69, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 29, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 30, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_ACOS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ACOS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 33, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ACOS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 34, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 75, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -59757,16 +49727,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_358stream_ACOS(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_361stream_AD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_369stream_AD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_360stream_AD, " AD(high, low, close, volume)\n\n Chaikin A/D Line (Volume Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close', 'volume']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_361stream_AD = {"stream_AD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_361stream_AD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_360stream_AD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_361stream_AD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -59789,7 +49759,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_AD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -59797,72 +49767,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 77, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 77, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 77, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 77, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 36, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 36, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, 1); __PYX_ERR(4, 36, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 36, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, 2); __PYX_ERR(4, 36, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_volume)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 36, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, 3); __PYX_ERR(4, 36, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_AD") < 0)) __PYX_ERR(4, 36, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 77, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 77, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 77, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 77, __pyx_L3_error) } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); @@ -59871,42 +49815,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 36, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 77, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_AD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 38, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 38, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 38, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 38, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_360stream_AD(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 79, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 79, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 79, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(5, 79, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_368stream_AD(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_360stream_AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume) { +static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -59919,8 +49862,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_360stream_AD(CYTHON_UNUSED PyObject *_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -59930,51 +49872,47 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_360stream_AD(CYTHON_UNUSED PyObject *_ __Pyx_INCREF((PyObject *)__pyx_v_close); __Pyx_INCREF((PyObject *)__pyx_v_volume); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 58, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 59, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 60, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 61, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 62, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 63, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 64, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 65, __pyx_L1_error) - __pyx_v_volume_data = ((double *)__pyx_t_2); + __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 66, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_AD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 69, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 70, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -59998,16 +49936,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_360stream_AD(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_363stream_ADD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_371stream_ADD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_362stream_ADD, " ADD(real0, real1)\n\n Vector Arithmetic Add (Math Operators)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_363stream_ADD = {"stream_ADD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_363stream_ADD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_362stream_ADD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_363stream_ADD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -60028,7 +49966,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ADD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -60036,86 +49974,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 113, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 113, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 72, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 72, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ADD", 1, 2, 2, 1); __PYX_ERR(4, 72, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ADD") < 0)) __PYX_ERR(4, 72, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 113, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 113, __pyx_L3_error) } __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ADD", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 72, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ADD", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 113, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ADD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 74, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 74, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_362stream_ADD(__pyx_self, __pyx_v_real0, __pyx_v_real1); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 115, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 115, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_370stream_ADD(__pyx_self, __pyx_v_real0, __pyx_v_real1); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_362stream_ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { +static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real0_data; @@ -60126,8 +50051,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362stream_ADD(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -60135,35 +50059,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362stream_ADD(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 93, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 94, __pyx_L1_error) - __pyx_v_real0_data = ((double *)__pyx_t_2); + __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 95, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 96, __pyx_L1_error) - __pyx_v_real1_data = ((double *)__pyx_t_2); + __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 97, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_ADD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 100, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 101, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -60185,16 +50107,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362stream_ADD(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_365stream_ADOSC(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_373stream_ADOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_364stream_ADOSC, " ADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\n Chaikin A/D Oscillator (Volume Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close', 'volume']\n Parameters:\n fastperiod: 3\n slowperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_365stream_ADOSC = {"stream_ADOSC", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_365stream_ADOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_364stream_ADOSC}; -static PyObject *__pyx_pw_5talib_7_ta_lib_365stream_ADOSC(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -60219,7 +50141,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ADOSC (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -60227,93 +50149,62 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 103, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 103, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, 1); __PYX_ERR(4, 103, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 103, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, 2); __PYX_ERR(4, 103, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_volume)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 103, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, 3); __PYX_ERR(4, 103, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 103, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 103, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ADOSC") < 0)) __PYX_ERR(4, 103, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 144, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 144, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 144, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 144, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 144, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -60323,54 +50214,53 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_close = ((PyArrayObject *)values[2]); __pyx_v_volume = ((PyArrayObject *)values[3]); if (values[4]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 105, __pyx_L3_error) + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 146, __pyx_L3_error) } else { __pyx_v_fastperiod = ((int)((int)-2147483648)); } if (values[5]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 105, __pyx_L3_error) + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 146, __pyx_L3_error) } else { __pyx_v_slowperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, __pyx_nargs); __PYX_ERR(4, 103, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, __pyx_nargs); __PYX_ERR(5, 144, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 105, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 105, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 105, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 105, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_364stream_ADOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_fastperiod, __pyx_v_slowperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 146, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 146, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 146, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(5, 146, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_372stream_ADOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_fastperiod, __pyx_v_slowperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -60383,8 +50273,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ADOSC(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -60394,51 +50283,47 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ADOSC(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_close); __Pyx_INCREF((PyObject *)__pyx_v_volume); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 128, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 169, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 129, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 130, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 131, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 132, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 173, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 133, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 134, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 135, __pyx_L1_error) - __pyx_v_volume_data = ((double *)__pyx_t_2); + __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 136, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_ADOSC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, __pyx_v_fastperiod, __pyx_v_slowperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 139, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 140, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -60462,16 +50347,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ADOSC(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_367stream_ADX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_375stream_ADX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_366stream_ADX, " ADX(high, low, close[, timeperiod=?])\n\n Average Directional Movement Index (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_367stream_ADX = {"stream_ADX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_367stream_ADX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_366stream_ADX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_367stream_ADX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -60494,7 +50379,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ADX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -60502,69 +50387,255 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 183, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 183, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 183, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 183, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 142, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 183, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 142, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, 1); __PYX_ERR(4, 142, __pyx_L3_error) - } + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 183, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 183, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 183, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_high = ((PyArrayObject *)values[0]); + __pyx_v_low = ((PyArrayObject *)values[1]); + __pyx_v_close = ((PyArrayObject *)values[2]); + if (values[3]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 185, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 183, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.stream_ADX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 185, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 185, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 185, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_374stream_ADX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { + npy_intp __pyx_v_length; + TA_RetCode __pyx_v_retCode; + double *__pyx_v_high_data; + double *__pyx_v_low_data; + double *__pyx_v_close_data; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + double __pyx_v_outreal; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_intp __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("stream_ADX", 0); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __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)-1L))) __PYX_ERR(5, 212, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; + + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_retCode = TA_ADX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.stream_ADX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_377stream_ADXR(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + int __pyx_v_timeperiod; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stream_ADXR (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 218, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 218, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 142, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, 2); __PYX_ERR(4, 142, __pyx_L3_error) - } + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 218, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 142, __pyx_L3_error) - } + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 218, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ADX") < 0)) __PYX_ERR(4, 142, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 218, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 218, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 218, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 218, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -60573,48 +50644,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 144, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 220, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 142, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 218, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_ADX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 144, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 144, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 144, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_366stream_ADX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 220, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 220, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 220, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_376stream_ADXR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -60626,53 +50696,49 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ADX(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_ADX", 0); + __Pyx_RefNannySetupContext("stream_ADXR", 0); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 165, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 166, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 167, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 168, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 169, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 170, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 171, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_ADX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_ADXR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 174, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADXR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 175, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -60682,7 +50748,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ADX(CYTHON_UNUSED PyObject * /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_ADX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_high); @@ -60695,249 +50761,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ADX(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_369stream_ADXR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_379stream_APO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_368stream_ADXR, " ADXR(high, low, close[, timeperiod=?])\n\n Average Directional Movement Index Rating (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_369stream_ADXR = {"stream_ADXR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_369stream_ADXR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_368stream_ADXR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_369stream_ADXR(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; - PyArrayObject *__pyx_v_close = 0; - int __pyx_v_timeperiod; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_ADXR (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 177, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 177, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, 1); __PYX_ERR(4, 177, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 177, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, 2); __PYX_ERR(4, 177, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 177, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ADXR") < 0)) __PYX_ERR(4, 177, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_high = ((PyArrayObject *)values[0]); - __pyx_v_low = ((PyArrayObject *)values[1]); - __pyx_v_close = ((PyArrayObject *)values[2]); - if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 179, __pyx_L3_error) - } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 177, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("talib._ta_lib.stream_ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 179, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 179, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 179, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_368stream_ADXR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { - npy_intp __pyx_v_length; - TA_RetCode __pyx_v_retCode; - double *__pyx_v_high_data; - double *__pyx_v_low_data; - double *__pyx_v_close_data; - int __pyx_v_outbegidx; - int __pyx_v_outnbelement; - double __pyx_v_outreal; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_ADXR", 0); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - __Pyx_INCREF((PyObject *)__pyx_v_close); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 200, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 201, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 202, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 203, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 204, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 205, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); - - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 206, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; - - __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - - __pyx_v_retCode = TA_ADXR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADXR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 209, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); - __Pyx_XDECREF((PyObject *)__pyx_v_close); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - - -/* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_371stream_APO(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_370stream_APO, " APO(real[, fastperiod=?, slowperiod=?, matype=?])\n\n Absolute Price Oscillator (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_371stream_APO = {"stream_APO", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_371stream_APO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_370stream_APO}; -static PyObject *__pyx_pw_5talib_7_ta_lib_371stream_APO(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -60960,7 +50793,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_APO (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -60968,121 +50801,107 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 253, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 253, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 253, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 253, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 212, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 212, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 212, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 212, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_APO") < 0)) __PYX_ERR(4, 212, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 253, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 253, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 253, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 253, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 214, __pyx_L3_error) + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 255, __pyx_L3_error) } else { __pyx_v_fastperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 214, __pyx_L3_error) + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 255, __pyx_L3_error) } else { __pyx_v_slowperiod = ((int)((int)-2147483648)); } if (values[3]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 214, __pyx_L3_error) + __pyx_v_matype = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 255, __pyx_L3_error) } else { __pyx_v_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_APO", 0, 1, 4, __pyx_nargs); __PYX_ERR(4, 212, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_APO", 0, 1, 4, __pyx_nargs); __PYX_ERR(5, 253, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_APO", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 214, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_370stream_APO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 255, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_378stream_APO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -61092,35 +50911,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_APO(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_APO", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 235, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 236, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 237, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_APO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_APO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 240, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_APO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 241, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -61141,16 +50956,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_APO(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_373stream_AROON(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_381stream_AROON(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_372stream_AROON, " AROON(high, low[, timeperiod=?])\n\n Aroon (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n aroondown\n aroonup\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_373stream_AROON = {"stream_AROON", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_373stream_AROON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_372stream_AROON}; -static PyObject *__pyx_pw_5talib_7_ta_lib_373stream_AROON(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -61172,7 +50987,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_AROON (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -61180,56 +50995,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 284, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 284, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 284, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 243, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 243, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_AROON", 0, 2, 3, 1); __PYX_ERR(4, 243, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 243, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_AROON") < 0)) __PYX_ERR(4, 243, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 284, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 284, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 284, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -61237,47 +51038,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 245, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 286, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_AROON", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 243, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_AROON", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 284, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_AROON", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 245, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 245, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_372stream_AROON(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 286, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 286, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_380stream_AROON(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -61289,10 +51089,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_AROON(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -61300,24 +51099,22 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_AROON(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 267, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 268, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 269, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 270, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 271, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; @@ -61325,33 +51122,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_AROON(CYTHON_UNUSED PyObject __pyx_v_retCode = TA_AROON((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outaroondown), (&__pyx_v_outaroonup)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AROON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 275, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AROON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outaroondown); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 276, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outaroondown); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outaroonup); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 276, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outaroonup); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(4, 276, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(4, 276, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 317, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(5, 317, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("talib._ta_lib.stream_AROON", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -61364,16 +51161,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_AROON(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_375stream_AROONOSC(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_383stream_AROONOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_374stream_AROONOSC, " AROONOSC(high, low[, timeperiod=?])\n\n Aroon Oscillator (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_375stream_AROONOSC = {"stream_AROONOSC", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_375stream_AROONOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_374stream_AROONOSC}; -static PyObject *__pyx_pw_5talib_7_ta_lib_375stream_AROONOSC(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -61395,7 +51192,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_AROONOSC (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -61403,56 +51200,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 319, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 319, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 319, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 278, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 278, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_AROONOSC", 0, 2, 3, 1); __PYX_ERR(4, 278, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 278, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_AROONOSC") < 0)) __PYX_ERR(4, 278, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 319, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 319, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 319, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -61460,47 +51243,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 280, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 321, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_AROONOSC", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 278, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_AROONOSC", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 319, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 280, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 280, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 321, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 321, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_382stream_AROONOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -61511,8 +51293,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -61520,35 +51301,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 300, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 301, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 302, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 303, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 304, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_AROONOSC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AROONOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 307, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AROONOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 308, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -61570,16 +51349,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_377stream_ASIN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_385stream_ASIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_376stream_ASIN, " ASIN(real)\n\n Vector Trigonometric ASin (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_377stream_ASIN = {"stream_ASIN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_377stream_ASIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_376stream_ASIN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_377stream_ASIN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -61599,7 +51378,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ASIN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -61607,71 +51386,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 351, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 310, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ASIN") < 0)) __PYX_ERR(4, 310, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 351, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ASIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 310, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ASIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 351, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ASIN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 312, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_376stream_ASIN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 353, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_384stream_ASIN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -61681,35 +51454,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ASIN(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_ASIN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 329, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 330, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 331, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_ASIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ASIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 334, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ASIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 335, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -61730,16 +51499,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ASIN(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_379stream_ATAN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_387stream_ATAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_378stream_ATAN, " ATAN(real)\n\n Vector Trigonometric ATan (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_379stream_ATAN = {"stream_ATAN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_379stream_ATAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_378stream_ATAN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_379stream_ATAN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -61759,7 +51528,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ATAN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -61767,71 +51536,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 378, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 337, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ATAN") < 0)) __PYX_ERR(4, 337, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 378, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ATAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 337, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ATAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 378, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ATAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 339, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_378stream_ATAN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 380, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_386stream_ATAN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -61841,35 +51604,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_ATAN(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_ATAN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 356, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 357, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 358, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_ATAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ATAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 361, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ATAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 402, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 362, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -61890,16 +51649,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_ATAN(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_381stream_ATR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_389stream_ATR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_380stream_ATR, " ATR(high, low, close[, timeperiod=?])\n\n Average True Range (Volatility Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_381stream_ATR = {"stream_ATR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_381stream_ATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_380stream_ATR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_381stream_ATR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -61922,7 +51681,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ATR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -61930,69 +51689,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 405, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 405, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 405, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 405, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 364, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 364, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, 1); __PYX_ERR(4, 364, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 364, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, 2); __PYX_ERR(4, 364, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 364, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ATR") < 0)) __PYX_ERR(4, 364, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 405, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 405, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 405, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 405, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -62001,48 +51739,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 366, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 407, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 364, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 405, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ATR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 366, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 366, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 366, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_380stream_ATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 407, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 407, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 407, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_388stream_ATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -62054,8 +51791,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_ATR(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -62064,43 +51800,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_ATR(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 387, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 388, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 389, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 390, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 391, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 392, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 393, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_ATR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 396, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 397, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -62123,16 +51856,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_ATR(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_383stream_AVGPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_391stream_AVGPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_382stream_AVGPRICE, " AVGPRICE(open, high, low, close)\n\n Average Price (Price Transform)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_383stream_AVGPRICE = {"stream_AVGPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_383stream_AVGPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_382stream_AVGPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_383stream_AVGPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -62155,7 +51888,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_AVGPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -62163,72 +51896,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 440, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 440, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 440, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 440, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 399, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 399, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, 1); __PYX_ERR(4, 399, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 399, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, 2); __PYX_ERR(4, 399, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 399, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, 3); __PYX_ERR(4, 399, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_AVGPRICE") < 0)) __PYX_ERR(4, 399, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 440, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 440, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 440, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 440, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -62237,42 +51944,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 399, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 440, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 401, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 401, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 401, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 401, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 442, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 442, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 442, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 442, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_390stream_AVGPRICE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -62285,8 +51991,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -62296,51 +52001,47 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 421, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 422, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 423, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 464, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 424, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 425, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 426, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 427, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 468, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 428, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 429, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_AVGPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AVGPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 432, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AVGPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 433, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -62364,16 +52065,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_385stream_BBANDS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_393stream_AVGDEV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_384stream_BBANDS, " BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\n Bollinger Bands (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 5\n nbdevup: 2.0\n nbdevdn: 2.0\n matype: 0 (Simple Moving Average)\n Outputs:\n upperband\n middleband\n lowerband\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_385stream_BBANDS = {"stream_BBANDS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_385stream_BBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_384stream_BBANDS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_385stream_BBANDS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -62382,22 +52083,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; - double __pyx_v_nbdevup; - double __pyx_v_nbdevdn; - int __pyx_v_matype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_BBANDS (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_AVGDEV (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -62405,137 +52103,290 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdevup,&__pyx_n_s_nbdevdn,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 476, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 476, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 435, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 476, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 435, __pyx_L3_error) - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 476, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 478, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stream_AVGDEV", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 476, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.stream_AVGDEV", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 478, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_392stream_AVGDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_AVGDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { + npy_intp __pyx_v_length; + TA_RetCode __pyx_v_retCode; + double *__pyx_v_real_data; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + double __pyx_v_outreal; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("stream_AVGDEV", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); + + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); + + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_retCode = TA_AVGDEV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AVGDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.stream_AVGDEV", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_real); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_395stream_BBANDS(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_real = 0; + int __pyx_v_timeperiod; + double __pyx_v_nbdevup; + double __pyx_v_nbdevdn; + int __pyx_v_matype; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stream_BBANDS (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 505, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nbdevup); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 435, __pyx_L3_error) - } + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 505, __pyx_L3_error) CYTHON_FALLTHROUGH; case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nbdevdn); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 435, __pyx_L3_error) - } + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 505, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 435, __pyx_L3_error) - } + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 505, __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(5, 505, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_BBANDS") < 0)) __PYX_ERR(4, 435, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 505, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 505, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 505, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 505, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 505, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 437, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 507, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_nbdevup = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdevup == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 437, __pyx_L3_error) + __pyx_v_nbdevup = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdevup == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 507, __pyx_L3_error) } else { __pyx_v_nbdevup = ((double)((double)-4e37)); } if (values[3]) { - __pyx_v_nbdevdn = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_nbdevdn == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 437, __pyx_L3_error) + __pyx_v_nbdevdn = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_nbdevdn == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 507, __pyx_L3_error) } else { __pyx_v_nbdevdn = ((double)((double)-4e37)); } if (values[4]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 437, __pyx_L3_error) + __pyx_v_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 507, __pyx_L3_error) } else { __pyx_v_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_BBANDS", 0, 1, 5, __pyx_nargs); __PYX_ERR(4, 435, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_BBANDS", 0, 1, 5, __pyx_nargs); __PYX_ERR(5, 505, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 437, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_384stream_BBANDS(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 507, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_394stream_BBANDS(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -62547,27 +52398,23 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_BBANDS(CYTHON_UNUSED PyObjec PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_BBANDS", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 463, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 533, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 464, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 465, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outrealupperband = __pyx_v_5talib_7_ta_lib_NaN; @@ -62577,39 +52424,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_BBANDS(CYTHON_UNUSED PyObjec __pyx_v_retCode = TA_BBANDS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outrealupperband), (&__pyx_v_outrealmiddleband), (&__pyx_v_outreallowerband)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 470, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 540, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outrealupperband); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 471, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outrealupperband); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outrealmiddleband); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 471, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outrealmiddleband); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 541, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outreallowerband); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 541, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_outreallowerband); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1)) __PYX_ERR(4, 471, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(4, 471, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(4, 471, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 541, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 541, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(5, 541, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __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.stream_BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -62621,16 +52468,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_BBANDS(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_387stream_BETA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_397stream_BETA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_386stream_BETA, " BETA(real0, real1[, timeperiod=?])\n\n Beta (Statistic Functions)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Parameters:\n timeperiod: 5\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_387stream_BETA = {"stream_BETA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_387stream_BETA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_386stream_BETA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_387stream_BETA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -62652,7 +52499,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_BETA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -62660,56 +52507,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 543, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 543, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 543, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 473, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 473, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_BETA", 0, 2, 3, 1); __PYX_ERR(4, 473, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 473, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_BETA") < 0)) __PYX_ERR(4, 473, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 543, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 543, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 543, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -62717,47 +52550,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 475, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 545, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_BETA", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 473, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_BETA", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 543, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_BETA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 475, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 475, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_386stream_BETA(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 545, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 545, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_396stream_BETA(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real0_data; @@ -62768,8 +52600,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_BETA(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -62777,35 +52608,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_BETA(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 496, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 497, __pyx_L1_error) - __pyx_v_real0_data = ((double *)__pyx_t_2); + __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 498, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 499, __pyx_L1_error) - __pyx_v_real1_data = ((double *)__pyx_t_2); + __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 500, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_BETA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BETA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 503, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BETA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 504, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -62827,16 +52656,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_BETA(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_389stream_BOP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_399stream_BOP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_388stream_BOP, " BOP(open, high, low, close)\n\n Balance Of Power (Momentum Indicators)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_389stream_BOP = {"stream_BOP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_389stream_BOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_388stream_BOP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_389stream_BOP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -62859,7 +52688,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_BOP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -62867,72 +52696,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 576, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 576, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 576, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 576, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 506, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 506, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, 1); __PYX_ERR(4, 506, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 506, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, 2); __PYX_ERR(4, 506, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 506, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, 3); __PYX_ERR(4, 506, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_BOP") < 0)) __PYX_ERR(4, 506, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 576, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 576, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 576, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 576, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -62941,42 +52744,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 506, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 576, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_BOP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 508, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 508, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 508, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 508, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_388stream_BOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 578, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 578, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 578, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 578, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_398stream_BOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -62989,8 +52791,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_BOP(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -63000,51 +52801,47 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_BOP(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 528, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 529, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 530, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 531, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 532, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 533, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 534, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 535, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 536, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_BOP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 539, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 540, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -63068,16 +52865,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_BOP(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_391stream_CCI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_401stream_CCI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_390stream_CCI, " CCI(high, low, close[, timeperiod=?])\n\n Commodity Channel Index (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_391stream_CCI = {"stream_CCI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_391stream_CCI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_390stream_CCI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_391stream_CCI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -63100,7 +52897,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_CCI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -63108,69 +52905,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 612, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 612, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 612, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 612, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 542, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 542, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, 1); __PYX_ERR(4, 542, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 542, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, 2); __PYX_ERR(4, 542, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 542, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CCI") < 0)) __PYX_ERR(4, 542, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 612, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 612, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 612, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 612, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -63179,48 +52955,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 544, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 614, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 542, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 612, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_CCI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 544, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 544, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 544, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_390stream_CCI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 614, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 614, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 614, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_400stream_CCI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -63232,8 +53007,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_CCI(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -63242,43 +53016,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_CCI(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 565, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 635, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 566, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 567, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 637, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 568, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 569, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 639, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 570, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 571, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_CCI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CCI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 574, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CCI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 575, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 645, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -63301,16 +53072,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_CCI(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_393stream_CDL2CROWS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_403stream_CDL2CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_392stream_CDL2CROWS, " CDL2CROWS(open, high, low, close)\n\n Two Crows (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_393stream_CDL2CROWS = {"stream_CDL2CROWS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_393stream_CDL2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_392stream_CDL2CROWS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_393stream_CDL2CROWS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -63333,7 +53104,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_CDL2CROWS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -63341,72 +53112,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 647, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 647, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 647, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 647, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 577, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 577, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, 1); __PYX_ERR(4, 577, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 577, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, 2); __PYX_ERR(4, 577, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 577, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, 3); __PYX_ERR(4, 577, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDL2CROWS") < 0)) __PYX_ERR(4, 577, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 647, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 647, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 647, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 647, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -63415,42 +53160,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 577, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 647, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 579, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 579, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 579, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 579, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_392stream_CDL2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 649, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 649, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 649, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 649, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_402stream_CDL2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -63463,8 +53207,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_CDL2CROWS(CYTHON_UNUSED PyOb PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -63474,51 +53217,47 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_CDL2CROWS(CYTHON_UNUSED PyOb __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 599, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 669, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 600, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 601, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 671, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 602, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 603, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 673, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 604, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 605, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 606, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 607, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_CDL2CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 610, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 680, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 611, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -63542,16 +53281,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_CDL2CROWS(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_395stream_CDL3BLACKCROWS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_405stream_CDL3BLACKCROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_394stream_CDL3BLACKCROWS, " CDL3BLACKCROWS(open, high, low, close)\n\n Three Black Crows (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_395stream_CDL3BLACKCROWS = {"stream_CDL3BLACKCROWS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_395stream_CDL3BLACKCROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_394stream_CDL3BLACKCROWS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_395stream_CDL3BLACKCROWS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -63574,7 +53313,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_CDL3BLACKCROWS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -63582,72 +53321,255 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 683, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 683, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 683, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 683, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 683, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 683, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 683, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 683, __pyx_L3_error) + } + __pyx_v_open = ((PyArrayObject *)values[0]); + __pyx_v_high = ((PyArrayObject *)values[1]); + __pyx_v_low = ((PyArrayObject *)values[2]); + __pyx_v_close = ((PyArrayObject *)values[3]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 683, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 685, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 685, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 685, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 685, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_404stream_CDL3BLACKCROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { + npy_intp __pyx_v_length; + TA_RetCode __pyx_v_retCode; + double *__pyx_v_open_data; + double *__pyx_v_high_data; + double *__pyx_v_low_data; + double *__pyx_v_close_data; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + int __pyx_v_outinteger; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_intp __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("stream_CDL3BLACKCROWS", 0); + __Pyx_INCREF((PyObject *)__pyx_v_open); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __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)-1L))) __PYX_ERR(5, 713, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; + + __pyx_v_outinteger = 0; + + __pyx_v_retCode = TA_CDL3BLACKCROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3BLACKCROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 716, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_open); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_407stream_CDL3INSIDE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_open = 0; + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stream_CDL3INSIDE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 613, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 719, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 613, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, 1); __PYX_ERR(4, 613, __pyx_L3_error) - } + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 719, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 613, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, 2); __PYX_ERR(4, 613, __pyx_L3_error) - } + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 719, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 613, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, 3); __PYX_ERR(4, 613, __pyx_L3_error) - } + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 719, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDL3BLACKCROWS") < 0)) __PYX_ERR(4, 613, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 719, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 719, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 719, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 719, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -63656,42 +53578,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 613, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 719, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 615, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 615, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 615, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 615, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_394stream_CDL3BLACKCROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 721, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 721, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 721, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 721, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_406stream_CDL3INSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -63704,62 +53625,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDL3BLACKCROWS", 0); + __Pyx_RefNannySetupContext("stream_CDL3INSIDE", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 635, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 741, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 636, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 637, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 638, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 639, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 640, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 641, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 642, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 643, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDL3BLACKCROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDL3INSIDE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3BLACKCROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 646, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3INSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 647, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -63769,7 +53685,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_CDL3BLACKCROWS(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -63783,16 +53699,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_CDL3BLACKCROWS(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_397stream_CDL3INSIDE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_409stream_CDL3LINESTRIKE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_396stream_CDL3INSIDE, " CDL3INSIDE(open, high, low, close)\n\n Three Inside Up/Down (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_397stream_CDL3INSIDE = {"stream_CDL3INSIDE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_397stream_CDL3INSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_396stream_CDL3INSIDE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_397stream_CDL3INSIDE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -63813,9 +53729,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDL3INSIDE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDL3LINESTRIKE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -63823,72 +53739,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 755, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 755, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 755, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 755, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 649, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 649, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, 1); __PYX_ERR(4, 649, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 649, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, 2); __PYX_ERR(4, 649, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 649, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, 3); __PYX_ERR(4, 649, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDL3INSIDE") < 0)) __PYX_ERR(4, 649, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 755, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 755, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 755, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 755, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -63897,42 +53787,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 649, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 755, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 651, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 651, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 651, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 651, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 757, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 757, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 757, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 757, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_408stream_CDL3LINESTRIKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -63945,62 +53834,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(CYTHON_UNUSED PyO PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDL3INSIDE", 0); + __Pyx_RefNannySetupContext("stream_CDL3LINESTRIKE", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 671, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 777, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 672, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 673, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 674, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 675, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 676, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 677, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 783, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 678, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 679, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDL3INSIDE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDL3LINESTRIKE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3INSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 682, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3LINESTRIKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 683, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -64010,7 +53894,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(CYTHON_UNUSED PyO /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -64024,16 +53908,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_399stream_CDL3LINESTRIKE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_411stream_CDL3OUTSIDE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_398stream_CDL3LINESTRIKE, " CDL3LINESTRIKE(open, high, low, close)\n\n Three-Line Strike (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_399stream_CDL3LINESTRIKE = {"stream_CDL3LINESTRIKE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_399stream_CDL3LINESTRIKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_398stream_CDL3LINESTRIKE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_399stream_CDL3LINESTRIKE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -64054,9 +53938,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDL3LINESTRIKE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDL3OUTSIDE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -64064,72 +53948,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 791, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 791, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 791, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 791, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 685, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 685, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, 1); __PYX_ERR(4, 685, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 685, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, 2); __PYX_ERR(4, 685, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 685, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, 3); __PYX_ERR(4, 685, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDL3LINESTRIKE") < 0)) __PYX_ERR(4, 685, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 791, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 791, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 791, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 791, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -64138,42 +53996,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 685, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 791, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 687, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 687, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 687, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 687, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 793, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 793, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 793, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 793, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_410stream_CDL3OUTSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -64186,62 +54043,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDL3LINESTRIKE", 0); + __Pyx_RefNannySetupContext("stream_CDL3OUTSIDE", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 707, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 708, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 709, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 710, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 711, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 712, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 713, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 714, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 715, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDL3LINESTRIKE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDL3OUTSIDE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3LINESTRIKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 718, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3OUTSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 719, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -64251,7 +54103,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -64265,16 +54117,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_401stream_CDL3OUTSIDE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_400stream_CDL3OUTSIDE, " CDL3OUTSIDE(open, high, low, close)\n\n Three Outside Up/Down (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_401stream_CDL3OUTSIDE = {"stream_CDL3OUTSIDE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_401stream_CDL3OUTSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_400stream_CDL3OUTSIDE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_401stream_CDL3OUTSIDE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -64295,9 +54147,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDL3OUTSIDE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDL3STARSINSOUTH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -64305,72 +54157,255 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 827, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 827, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 827, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 827, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 827, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 827, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 827, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 827, __pyx_L3_error) + } + __pyx_v_open = ((PyArrayObject *)values[0]); + __pyx_v_high = ((PyArrayObject *)values[1]); + __pyx_v_low = ((PyArrayObject *)values[2]); + __pyx_v_close = ((PyArrayObject *)values[3]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 827, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 829, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 829, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 829, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 829, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { + npy_intp __pyx_v_length; + TA_RetCode __pyx_v_retCode; + double *__pyx_v_open_data; + double *__pyx_v_high_data; + double *__pyx_v_low_data; + double *__pyx_v_close_data; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + int __pyx_v_outinteger; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_intp __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("stream_CDL3STARSINSOUTH", 0); + __Pyx_INCREF((PyObject *)__pyx_v_open); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 849, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 851, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __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)-1L))) __PYX_ERR(5, 857, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; + + __pyx_v_outinteger = 0; + + __pyx_v_retCode = TA_CDL3STARSINSOUTH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3STARSINSOUTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 860, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 861, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_open); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_open = 0; + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stream_CDL3WHITESOLDIERS (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 721, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 863, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 721, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, 1); __PYX_ERR(4, 721, __pyx_L3_error) - } + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 863, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 721, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, 2); __PYX_ERR(4, 721, __pyx_L3_error) - } + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 863, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 721, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, 3); __PYX_ERR(4, 721, __pyx_L3_error) - } + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 863, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDL3OUTSIDE") < 0)) __PYX_ERR(4, 721, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 863, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 863, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 863, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 863, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -64379,42 +54414,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 721, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 863, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 723, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 723, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 723, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 723, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 865, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 865, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 865, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 865, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -64427,62 +54461,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(CYTHON_UNUSED Py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDL3OUTSIDE", 0); + __Pyx_RefNannySetupContext("stream_CDL3WHITESOLDIERS", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 743, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 885, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 744, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 745, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 746, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 747, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 748, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 749, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 750, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 751, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDL3OUTSIDE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDL3WHITESOLDIERS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3OUTSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 754, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3WHITESOLDIERS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 755, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -64492,7 +54521,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(CYTHON_UNUSED Py /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -64506,16 +54535,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_417stream_CDLABANDONEDBABY(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH, " CDL3STARSINSOUTH(open, high, low, close)\n\n Three Stars In The South (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH = {"stream_CDL3STARSINSOUTH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -64526,19 +54555,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; + double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDL3STARSINSOUTH (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLABANDONEDBABY (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -64546,116 +54576,105 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 899, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 899, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 899, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 899, __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(5, 899, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 757, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 757, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, 1); __PYX_ERR(4, 757, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 757, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, 2); __PYX_ERR(4, 757, __pyx_L3_error) - } + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 899, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 757, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, 3); __PYX_ERR(4, 757, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDL3STARSINSOUTH") < 0)) __PYX_ERR(4, 757, __pyx_L3_error) + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 899, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 899, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 899, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 899, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); + if (values[4]) { + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 901, __pyx_L3_error) + } else { + __pyx_v_penetration = ((double)((double)0.3)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 757, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 899, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 759, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 759, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 759, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 759, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 901, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 901, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 901, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 901, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_416stream_CDLABANDONEDBABY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -64668,62 +54687,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(CYTHON_UNUS PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDL3STARSINSOUTH", 0); + __Pyx_RefNannySetupContext("stream_CDLABANDONEDBABY", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 779, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 923, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 780, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 781, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 925, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 782, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 783, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 927, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 784, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 785, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 929, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 786, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 787, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDL3STARSINSOUTH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLABANDONEDBABY((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3STARSINSOUTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 790, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLABANDONEDBABY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 934, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 791, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 935, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -64733,7 +54747,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(CYTHON_UNUS /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -64747,16 +54761,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(CYTHON_UNUS /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS, " CDL3WHITESOLDIERS(open, high, low, close)\n\n Three Advancing White Soldiers (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS = {"stream_CDL3WHITESOLDIERS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -64777,9 +54791,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDL3WHITESOLDIERS (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLADVANCEBLOCK (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -64787,72 +54801,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 937, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 937, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 937, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 937, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 793, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 793, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, 1); __PYX_ERR(4, 793, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 793, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, 2); __PYX_ERR(4, 793, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 793, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, 3); __PYX_ERR(4, 793, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDL3WHITESOLDIERS") < 0)) __PYX_ERR(4, 793, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 937, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 937, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 937, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 937, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -64861,42 +54849,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 793, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 937, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 795, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 795, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 795, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 795, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 939, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 939, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 939, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 939, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -64909,62 +54896,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(CYTHON_UNU PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDL3WHITESOLDIERS", 0); + __Pyx_RefNannySetupContext("stream_CDLADVANCEBLOCK", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 815, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 959, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 816, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 817, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 961, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 818, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 819, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 963, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 820, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 821, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 965, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 822, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 823, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDL3WHITESOLDIERS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLADVANCEBLOCK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3WHITESOLDIERS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 826, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLADVANCEBLOCK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 970, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 827, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -64974,7 +54956,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(CYTHON_UNU /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -64988,16 +54970,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(CYTHON_UNU /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_407stream_CDLABANDONEDBABY(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_421stream_CDLBELTHOLD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_406stream_CDLABANDONEDBABY, " CDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\n Abandoned Baby (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_407stream_CDLABANDONEDBABY = {"stream_CDLABANDONEDBABY", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_407stream_CDLABANDONEDBABY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_406stream_CDLABANDONEDBABY}; -static PyObject *__pyx_pw_5talib_7_ta_lib_407stream_CDLABANDONEDBABY(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -65008,20 +54990,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; - double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLABANDONEDBABY (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLBELTHOLD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -65029,134 +55010,89 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 973, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 973, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 973, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 973, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 829, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 829, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, 1); __PYX_ERR(4, 829, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 829, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, 2); __PYX_ERR(4, 829, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 829, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, 3); __PYX_ERR(4, 829, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 829, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLABANDONEDBABY") < 0)) __PYX_ERR(4, 829, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 973, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 973, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 973, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 973, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); - if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 831, __pyx_L3_error) - } else { - __pyx_v_penetration = ((double)((double)0.3)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 829, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 973, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 831, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 831, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 831, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 831, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 975, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 975, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 975, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 975, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_420stream_CDLBELTHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -65169,62 +55105,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(CYTHON_UNUS PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLABANDONEDBABY", 0); + __Pyx_RefNannySetupContext("stream_CDLBELTHOLD", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 853, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 995, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 854, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 855, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 856, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 857, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 999, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 858, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 859, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 860, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 861, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLABANDONEDBABY((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLBELTHOLD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLABANDONEDBABY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 864, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLBELTHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 865, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1007, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -65234,7 +55165,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(CYTHON_UNUS /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -65248,16 +55179,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(CYTHON_UNUS /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_423stream_CDLBREAKAWAY(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK, " CDLADVANCEBLOCK(open, high, low, close)\n\n Advance Block (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK = {"stream_CDLADVANCEBLOCK", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK}; -static PyObject *__pyx_pw_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -65278,9 +55209,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLADVANCEBLOCK (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLBREAKAWAY (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -65288,72 +55219,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1009, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1009, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1009, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1009, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 867, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 867, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, 1); __PYX_ERR(4, 867, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 867, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, 2); __PYX_ERR(4, 867, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 867, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, 3); __PYX_ERR(4, 867, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLADVANCEBLOCK") < 0)) __PYX_ERR(4, 867, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1009, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1009, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1009, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1009, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -65362,42 +55267,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 867, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1009, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 869, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 869, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 869, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 869, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1011, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1011, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1011, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1011, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_422stream_CDLBREAKAWAY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -65410,62 +55314,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(CYTHON_UNUSE PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLADVANCEBLOCK", 0); + __Pyx_RefNannySetupContext("stream_CDLBREAKAWAY", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 889, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1031, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 890, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 891, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1033, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 892, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 893, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1035, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 894, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 895, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1037, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 896, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 897, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLADVANCEBLOCK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLBREAKAWAY((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLADVANCEBLOCK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 900, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLBREAKAWAY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1042, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 901, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1043, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -65475,7 +55374,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(CYTHON_UNUSE /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -65489,16 +55388,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(CYTHON_UNUSE /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_411stream_CDLBELTHOLD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_410stream_CDLBELTHOLD, " CDLBELTHOLD(open, high, low, close)\n\n Belt-hold (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_411stream_CDLBELTHOLD = {"stream_CDLBELTHOLD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_411stream_CDLBELTHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_410stream_CDLBELTHOLD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_411stream_CDLBELTHOLD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -65519,9 +55418,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLBELTHOLD (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLCLOSINGMARUBOZU (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -65529,72 +55428,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1045, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1045, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1045, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1045, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 903, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 903, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, 1); __PYX_ERR(4, 903, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 903, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, 2); __PYX_ERR(4, 903, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 903, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, 3); __PYX_ERR(4, 903, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLBELTHOLD") < 0)) __PYX_ERR(4, 903, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1045, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1045, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1045, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1045, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -65603,42 +55476,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 903, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1045, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 905, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 905, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 905, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 905, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1047, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1047, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1047, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1047, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -65651,62 +55523,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(CYTHON_UNUSED Py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLBELTHOLD", 0); + __Pyx_RefNannySetupContext("stream_CDLCLOSINGMARUBOZU", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 925, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1067, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 926, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 927, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1069, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 928, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 929, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1071, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 930, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 931, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1073, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 932, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 933, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLBELTHOLD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLCLOSINGMARUBOZU((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLBELTHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 936, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCLOSINGMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1078, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 937, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1079, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -65716,7 +55583,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(CYTHON_UNUSED Py /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -65730,16 +55597,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_413stream_CDLBREAKAWAY(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_412stream_CDLBREAKAWAY, " CDLBREAKAWAY(open, high, low, close)\n\n Breakaway (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_413stream_CDLBREAKAWAY = {"stream_CDLBREAKAWAY", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_413stream_CDLBREAKAWAY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_412stream_CDLBREAKAWAY}; -static PyObject *__pyx_pw_5talib_7_ta_lib_413stream_CDLBREAKAWAY(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -65760,9 +55627,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLBREAKAWAY (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLCONCEALBABYSWALL (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -65770,72 +55637,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1081, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1081, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1081, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1081, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 939, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 939, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, 1); __PYX_ERR(4, 939, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 939, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, 2); __PYX_ERR(4, 939, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 939, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, 3); __PYX_ERR(4, 939, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLBREAKAWAY") < 0)) __PYX_ERR(4, 939, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1081, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1081, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1081, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1081, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -65844,42 +55685,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 939, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1081, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 941, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 941, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 941, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 941, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1083, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1083, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1083, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1083, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -65892,62 +55732,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(CYTHON_UNUSED P PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLBREAKAWAY", 0); + __Pyx_RefNannySetupContext("stream_CDLCONCEALBABYSWALL", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 961, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 962, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 963, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 964, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 965, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 966, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 967, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 968, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 969, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLBREAKAWAY((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLCONCEALBABYSWALL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLBREAKAWAY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 972, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCONCEALBABYSWALL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 973, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -65957,7 +55792,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(CYTHON_UNUSED P /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -65971,16 +55806,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU, " CDLCLOSINGMARUBOZU(open, high, low, close)\n\n Closing Marubozu (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU = {"stream_CDLCLOSINGMARUBOZU", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU}; -static PyObject *__pyx_pw_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -66001,9 +55836,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLCLOSINGMARUBOZU (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLCOUNTERATTACK (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -66011,72 +55846,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1117, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1117, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1117, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1117, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 975, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 975, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, 1); __PYX_ERR(4, 975, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 975, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, 2); __PYX_ERR(4, 975, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 975, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, 3); __PYX_ERR(4, 975, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLCLOSINGMARUBOZU") < 0)) __PYX_ERR(4, 975, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1117, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1117, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1117, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1117, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -66085,42 +55894,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 975, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1117, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 977, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 977, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 977, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 977, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1119, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1119, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1119, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1119, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -66133,62 +55941,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(CYTHON_UN PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLCLOSINGMARUBOZU", 0); + __Pyx_RefNannySetupContext("stream_CDLCOUNTERATTACK", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 997, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 998, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 999, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1000, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1001, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1002, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1003, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1004, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1005, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLCLOSINGMARUBOZU((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLCOUNTERATTACK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCLOSINGMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1008, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCOUNTERATTACK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1150, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1009, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -66198,7 +56001,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(CYTHON_UN /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -66212,16 +56015,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(CYTHON_UN /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL, " CDLCONCEALBABYSWALL(open, high, low, close)\n\n Concealing Baby Swallow (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL = {"stream_CDLCONCEALBABYSWALL", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL}; -static PyObject *__pyx_pw_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -66232,19 +56035,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; + double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLCONCEALBABYSWALL (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLDARKCLOUDCOVER (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -66252,116 +56056,105 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1153, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1153, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1153, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1153, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1153, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1011, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1011, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, 1); __PYX_ERR(4, 1011, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1011, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, 2); __PYX_ERR(4, 1011, __pyx_L3_error) - } + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1153, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1011, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, 3); __PYX_ERR(4, 1011, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLCONCEALBABYSWALL") < 0)) __PYX_ERR(4, 1011, __pyx_L3_error) + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1153, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1153, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1153, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1153, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); + if (values[4]) { + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 1155, __pyx_L3_error) + } else { + __pyx_v_penetration = ((double)((double)0.5)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1011, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 1153, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1013, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1013, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1013, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1013, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1155, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1155, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1155, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1155, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -66374,62 +56167,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(CYTHON_U PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLCONCEALBABYSWALL", 0); + __Pyx_RefNannySetupContext("stream_CDLDARKCLOUDCOVER", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1033, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1177, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1034, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1035, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1036, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1037, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1038, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1039, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1040, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1041, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLCONCEALBABYSWALL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLDARKCLOUDCOVER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCONCEALBABYSWALL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1044, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDARKCLOUDCOVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1045, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -66439,7 +56227,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(CYTHON_U /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -66453,16 +56241,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(CYTHON_U /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_433stream_CDLDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK, " CDLCOUNTERATTACK(open, high, low, close)\n\n Counterattack (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK = {"stream_CDLCOUNTERATTACK", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK}; -static PyObject *__pyx_pw_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -66483,9 +56271,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLCOUNTERATTACK (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLDOJI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -66493,72 +56281,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1191, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1191, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1191, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1191, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1047, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1047, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, 1); __PYX_ERR(4, 1047, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1047, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, 2); __PYX_ERR(4, 1047, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1047, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, 3); __PYX_ERR(4, 1047, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLCOUNTERATTACK") < 0)) __PYX_ERR(4, 1047, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1191, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1191, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1191, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1191, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -66567,42 +56329,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1047, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1191, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1049, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1049, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1049, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1049, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1193, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1193, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1193, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1193, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_432stream_CDLDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -66615,62 +56376,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(CYTHON_UNUS PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLCOUNTERATTACK", 0); + __Pyx_RefNannySetupContext("stream_CDLDOJI", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1069, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1070, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1071, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1072, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1073, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1217, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1074, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1075, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1219, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1076, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1077, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLCOUNTERATTACK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCOUNTERATTACK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1080, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1081, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -66680,7 +56436,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(CYTHON_UNUS /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -66694,16 +56450,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(CYTHON_UNUS /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_435stream_CDLDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER, " CDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\n Dark Cloud Cover (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.5\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER = {"stream_CDLDARKCLOUDCOVER", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER}; -static PyObject *__pyx_pw_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -66714,20 +56470,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; - double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLDARKCLOUDCOVER (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLDOJISTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -66735,134 +56490,89 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1227, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1227, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1227, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1227, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1083, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1083, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, 1); __PYX_ERR(4, 1083, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1083, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, 2); __PYX_ERR(4, 1083, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1083, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, 3); __PYX_ERR(4, 1083, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1083, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLDARKCLOUDCOVER") < 0)) __PYX_ERR(4, 1083, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1227, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1227, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1227, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1227, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); - if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 1085, __pyx_L3_error) - } else { - __pyx_v_penetration = ((double)((double)0.5)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 1083, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1227, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1085, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1085, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1085, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1085, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1229, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1229, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1229, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1229, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_434stream_CDLDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -66875,62 +56585,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(CYTHON_UNU PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLDARKCLOUDCOVER", 0); + __Pyx_RefNannySetupContext("stream_CDLDOJISTAR", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1107, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1108, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1109, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1110, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1111, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1112, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1113, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1114, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1115, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLDARKCLOUDCOVER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDARKCLOUDCOVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1118, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1119, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -66940,7 +56645,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(CYTHON_UNU /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -66954,16 +56659,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(CYTHON_UNU /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_423stream_CDLDOJI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_422stream_CDLDOJI, " CDLDOJI(open, high, low, close)\n\n Doji (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_423stream_CDLDOJI = {"stream_CDLDOJI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_423stream_CDLDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_422stream_CDLDOJI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_423stream_CDLDOJI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -66984,9 +56689,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLDOJI (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLDRAGONFLYDOJI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -66994,72 +56699,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1263, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1263, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1263, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1263, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1121, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1121, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, 1); __PYX_ERR(4, 1121, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1121, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, 2); __PYX_ERR(4, 1121, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1121, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, 3); __PYX_ERR(4, 1121, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLDOJI") < 0)) __PYX_ERR(4, 1121, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1263, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1263, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1263, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1263, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -67068,42 +56747,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1121, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1263, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1123, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1123, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1123, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1123, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1265, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1265, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1265, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1265, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -67116,62 +56794,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObje PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLDOJI", 0); + __Pyx_RefNannySetupContext("stream_CDLDRAGONFLYDOJI", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1143, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1144, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1145, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1146, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1147, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1289, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1148, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1149, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1150, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1151, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLDRAGONFLYDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1154, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDRAGONFLYDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1155, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -67181,7 +56854,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObje /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -67195,16 +56868,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_425stream_CDLDOJISTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_439stream_CDLENGULFING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_424stream_CDLDOJISTAR, " CDLDOJISTAR(open, high, low, close)\n\n Doji Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_425stream_CDLDOJISTAR = {"stream_CDLDOJISTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_425stream_CDLDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_424stream_CDLDOJISTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_425stream_CDLDOJISTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -67225,9 +56898,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLDOJISTAR (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLENGULFING (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -67235,72 +56908,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1299, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1299, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1299, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1299, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1157, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1157, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, 1); __PYX_ERR(4, 1157, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1157, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, 2); __PYX_ERR(4, 1157, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1157, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, 3); __PYX_ERR(4, 1157, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLDOJISTAR") < 0)) __PYX_ERR(4, 1157, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1299, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1299, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1299, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1299, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -67309,42 +56956,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1157, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1299, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1159, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1159, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1159, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1159, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1301, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1301, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1301, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1301, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_438stream_CDLENGULFING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -67357,62 +57003,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(CYTHON_UNUSED Py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLDOJISTAR", 0); + __Pyx_RefNannySetupContext("stream_CDLENGULFING", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1179, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1180, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1181, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1182, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1183, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1184, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1185, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1186, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1187, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLENGULFING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1190, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLENGULFING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1191, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -67422,7 +57063,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(CYTHON_UNUSED Py /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -67436,16 +57077,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI, " CDLDRAGONFLYDOJI(open, high, low, close)\n\n Dragonfly Doji (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI = {"stream_CDLDRAGONFLYDOJI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -67456,19 +57097,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; + double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLDRAGONFLYDOJI (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLEVENINGDOJISTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -67476,116 +57118,105 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1335, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1335, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1335, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1335, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1335, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1193, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1193, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, 1); __PYX_ERR(4, 1193, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1193, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, 2); __PYX_ERR(4, 1193, __pyx_L3_error) - } + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1335, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1193, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, 3); __PYX_ERR(4, 1193, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLDRAGONFLYDOJI") < 0)) __PYX_ERR(4, 1193, __pyx_L3_error) + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1335, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1335, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1335, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1335, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); + if (values[4]) { + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 1337, __pyx_L3_error) + } else { + __pyx_v_penetration = ((double)((double)0.3)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1193, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 1335, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1195, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1195, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1195, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1195, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1337, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1337, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1337, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1337, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -67598,62 +57229,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(CYTHON_UNUS PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLDRAGONFLYDOJI", 0); + __Pyx_RefNannySetupContext("stream_CDLEVENINGDOJISTAR", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1215, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1359, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1216, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1217, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1218, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1219, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1363, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1220, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1221, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1222, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1223, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLDRAGONFLYDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLEVENINGDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDRAGONFLYDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1226, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLEVENINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1227, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -67663,7 +57289,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(CYTHON_UNUS /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -67677,16 +57303,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(CYTHON_UNUS /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_429stream_CDLENGULFING(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_443stream_CDLEVENINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_428stream_CDLENGULFING, " CDLENGULFING(open, high, low, close)\n\n Engulfing Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_429stream_CDLENGULFING = {"stream_CDLENGULFING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_429stream_CDLENGULFING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_428stream_CDLENGULFING}; -static PyObject *__pyx_pw_5talib_7_ta_lib_429stream_CDLENGULFING(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -67697,19 +57323,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; + double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLENGULFING (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLEVENINGSTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -67717,116 +57344,105 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1373, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1373, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1373, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1373, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1373, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1229, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1229, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, 1); __PYX_ERR(4, 1229, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1229, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, 2); __PYX_ERR(4, 1229, __pyx_L3_error) - } + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1373, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1229, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, 3); __PYX_ERR(4, 1229, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLENGULFING") < 0)) __PYX_ERR(4, 1229, __pyx_L3_error) + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1373, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1373, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1373, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1373, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); + if (values[4]) { + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 1375, __pyx_L3_error) + } else { + __pyx_v_penetration = ((double)((double)0.3)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1229, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 1373, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1231, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1231, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1231, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1231, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1375, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1375, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1375, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1375, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_442stream_CDLEVENINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -67839,62 +57455,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(CYTHON_UNUSED P PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLENGULFING", 0); + __Pyx_RefNannySetupContext("stream_CDLEVENINGSTAR", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1251, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1252, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1253, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1254, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1255, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1256, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1257, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1258, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1259, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLENGULFING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLEVENINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLENGULFING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1262, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLEVENINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1263, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -67904,7 +57515,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(CYTHON_UNUSED P /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -67918,16 +57529,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR, " CDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\n Evening Doji Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR = {"stream_CDLEVENINGDOJISTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -67938,20 +57549,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; - double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLEVENINGDOJISTAR (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLGAPSIDESIDEWHITE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -67959,134 +57569,89 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1411, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1411, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1411, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1411, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1265, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1265, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, 1); __PYX_ERR(4, 1265, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1265, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, 2); __PYX_ERR(4, 1265, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1265, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, 3); __PYX_ERR(4, 1265, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1265, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLEVENINGDOJISTAR") < 0)) __PYX_ERR(4, 1265, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1411, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1411, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1411, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1411, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); - if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 1267, __pyx_L3_error) - } else { - __pyx_v_penetration = ((double)((double)0.3)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 1265, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1411, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1267, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1267, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1267, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1267, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1413, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1413, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1413, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1413, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -68099,62 +57664,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UN PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLEVENINGDOJISTAR", 0); + __Pyx_RefNannySetupContext("stream_CDLGAPSIDESIDEWHITE", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1289, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1290, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1291, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1292, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1293, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1294, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1295, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1296, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1297, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLEVENINGDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLGAPSIDESIDEWHITE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLEVENINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1300, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLGAPSIDESIDEWHITE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1444, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1301, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -68164,7 +57724,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UN /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -68178,16 +57738,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UN /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_433stream_CDLEVENINGSTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_432stream_CDLEVENINGSTAR, " CDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\n Evening Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_433stream_CDLEVENINGSTAR = {"stream_CDLEVENINGSTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_433stream_CDLEVENINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_432stream_CDLEVENINGSTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_433stream_CDLEVENINGSTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -68198,20 +57758,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; - double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLEVENINGSTAR (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLGRAVESTONEDOJI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -68219,134 +57778,89 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1447, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1447, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1447, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1447, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1303, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1303, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, 1); __PYX_ERR(4, 1303, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1303, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, 2); __PYX_ERR(4, 1303, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1303, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, 3); __PYX_ERR(4, 1303, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1303, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLEVENINGSTAR") < 0)) __PYX_ERR(4, 1303, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1447, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1447, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1447, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1447, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); - if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 1305, __pyx_L3_error) - } else { - __pyx_v_penetration = ((double)((double)0.3)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 1303, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1447, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1305, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1305, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1305, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1305, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1449, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1449, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1449, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1449, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -68359,62 +57873,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLEVENINGSTAR", 0); + __Pyx_RefNannySetupContext("stream_CDLGRAVESTONEDOJI", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1327, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1328, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1329, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1330, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1331, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1332, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1333, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1334, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1335, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLEVENINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLGRAVESTONEDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLEVENINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1338, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLGRAVESTONEDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1339, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -68424,7 +57933,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -68438,16 +57947,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_449stream_CDLHAMMER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE, " CDLGAPSIDESIDEWHITE(open, high, low, close)\n\n Up/Down-gap side-by-side white lines (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE = {"stream_CDLGAPSIDESIDEWHITE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -68468,9 +57977,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLGAPSIDESIDEWHITE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLHAMMER (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -68478,72 +57987,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1483, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1483, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1483, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1483, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1341, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1341, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, 1); __PYX_ERR(4, 1341, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1341, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, 2); __PYX_ERR(4, 1341, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1341, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, 3); __PYX_ERR(4, 1341, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLGAPSIDESIDEWHITE") < 0)) __PYX_ERR(4, 1341, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1483, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1483, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1483, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1483, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -68552,42 +58035,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1341, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1483, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1343, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1343, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1343, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1343, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1485, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1485, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1485, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1485, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_448stream_CDLHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -68600,62 +58082,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_U PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLGAPSIDESIDEWHITE", 0); + __Pyx_RefNannySetupContext("stream_CDLHAMMER", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1363, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1364, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1365, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1366, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1367, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1509, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1368, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1369, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1511, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1370, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1371, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLGAPSIDESIDEWHITE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLHAMMER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLGAPSIDESIDEWHITE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1374, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1375, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -68665,7 +58142,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_U /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -68679,16 +58156,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_U /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_451stream_CDLHANGINGMAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI, " CDLGRAVESTONEDOJI(open, high, low, close)\n\n Gravestone Doji (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI = {"stream_CDLGRAVESTONEDOJI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -68709,9 +58186,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLGRAVESTONEDOJI (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLHANGINGMAN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -68719,72 +58196,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1519, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1519, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1519, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1519, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1377, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1377, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, 1); __PYX_ERR(4, 1377, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1377, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, 2); __PYX_ERR(4, 1377, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1377, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, 3); __PYX_ERR(4, 1377, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLGRAVESTONEDOJI") < 0)) __PYX_ERR(4, 1377, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1519, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1519, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1519, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1519, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -68793,42 +58244,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1377, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1519, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1379, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1379, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1379, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1379, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1521, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1521, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1521, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1521, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_450stream_CDLHANGINGMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -68841,62 +58291,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNU PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLGRAVESTONEDOJI", 0); + __Pyx_RefNannySetupContext("stream_CDLHANGINGMAN", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1399, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1400, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1401, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1543, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1402, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1403, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1404, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1405, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1406, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1407, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLGRAVESTONEDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLHANGINGMAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLGRAVESTONEDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1410, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHANGINGMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1552, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1411, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -68906,7 +58351,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNU /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -68920,16 +58365,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNU /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_439stream_CDLHAMMER(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_453stream_CDLHARAMI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_438stream_CDLHAMMER, " CDLHAMMER(open, high, low, close)\n\n Hammer (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_439stream_CDLHAMMER = {"stream_CDLHAMMER", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_439stream_CDLHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_438stream_CDLHAMMER}; -static PyObject *__pyx_pw_5talib_7_ta_lib_439stream_CDLHAMMER(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -68950,9 +58395,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLHAMMER (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLHARAMI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -68960,72 +58405,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1555, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1555, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1555, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1555, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1413, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1413, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, 1); __PYX_ERR(4, 1413, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1413, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, 2); __PYX_ERR(4, 1413, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1413, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, 3); __PYX_ERR(4, 1413, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLHAMMER") < 0)) __PYX_ERR(4, 1413, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1555, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1555, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1555, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1555, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -69034,42 +58453,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1413, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1555, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1415, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1415, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1415, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1415, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1557, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1557, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1557, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1557, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_452stream_CDLHARAMI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -69082,62 +58500,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyOb PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLHAMMER", 0); + __Pyx_RefNannySetupContext("stream_CDLHARAMI", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1435, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1436, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1437, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1438, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1439, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1440, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1441, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1442, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1443, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLHAMMER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLHARAMI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1446, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHARAMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1447, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -69147,7 +58560,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyOb /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -69161,16 +58574,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_441stream_CDLHANGINGMAN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_455stream_CDLHARAMICROSS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_440stream_CDLHANGINGMAN, " CDLHANGINGMAN(open, high, low, close)\n\n Hanging Man (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_441stream_CDLHANGINGMAN = {"stream_CDLHANGINGMAN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_441stream_CDLHANGINGMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_440stream_CDLHANGINGMAN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_441stream_CDLHANGINGMAN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -69191,9 +58604,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLHANGINGMAN (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLHARAMICROSS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -69201,72 +58614,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1591, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1591, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1591, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1591, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1449, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1449, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, 1); __PYX_ERR(4, 1449, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1449, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, 2); __PYX_ERR(4, 1449, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1449, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, 3); __PYX_ERR(4, 1449, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLHANGINGMAN") < 0)) __PYX_ERR(4, 1449, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1591, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1591, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1591, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1591, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -69275,42 +58662,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1449, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1591, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1451, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1451, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1451, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1451, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1593, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1593, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1593, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1593, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_454stream_CDLHARAMICROSS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -69323,62 +58709,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLHANGINGMAN", 0); + __Pyx_RefNannySetupContext("stream_CDLHARAMICROSS", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1471, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1613, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1472, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1473, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1615, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1474, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1475, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1476, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1477, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1478, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1479, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLHANGINGMAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLHARAMICROSS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHANGINGMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1482, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHARAMICROSS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1624, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1483, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1625, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -69388,7 +58769,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -69402,16 +58783,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_443stream_CDLHARAMI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_457stream_CDLHIGHWAVE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_442stream_CDLHARAMI, " CDLHARAMI(open, high, low, close)\n\n Harami Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_443stream_CDLHARAMI = {"stream_CDLHARAMI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_443stream_CDLHARAMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_442stream_CDLHARAMI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_443stream_CDLHARAMI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -69432,9 +58813,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLHARAMI (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLHIGHWAVE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -69442,72 +58823,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1627, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1627, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1627, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1627, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1485, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1485, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, 1); __PYX_ERR(4, 1485, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1485, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, 2); __PYX_ERR(4, 1485, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1485, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, 3); __PYX_ERR(4, 1485, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLHARAMI") < 0)) __PYX_ERR(4, 1485, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1627, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1627, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1627, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1627, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -69516,42 +58871,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1485, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1627, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1487, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1487, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1487, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1487, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1629, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1629, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1629, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1629, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_456stream_CDLHIGHWAVE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -69564,62 +58918,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyOb PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLHARAMI", 0); + __Pyx_RefNannySetupContext("stream_CDLHIGHWAVE", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1507, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1649, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1508, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1509, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1510, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1511, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1512, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1513, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1655, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1514, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1515, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLHARAMI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLHIGHWAVE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHARAMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1518, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIGHWAVE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1519, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -69629,7 +58978,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyOb /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -69643,16 +58992,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_445stream_CDLHARAMICROSS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_459stream_CDLHIKKAKE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_444stream_CDLHARAMICROSS, " CDLHARAMICROSS(open, high, low, close)\n\n Harami Cross Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_445stream_CDLHARAMICROSS = {"stream_CDLHARAMICROSS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_445stream_CDLHARAMICROSS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_444stream_CDLHARAMICROSS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_445stream_CDLHARAMICROSS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -69673,9 +59022,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLHARAMICROSS (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLHIKKAKE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -69683,72 +59032,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1663, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1663, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1663, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1663, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1521, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1521, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, 1); __PYX_ERR(4, 1521, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1521, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, 2); __PYX_ERR(4, 1521, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1521, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, 3); __PYX_ERR(4, 1521, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLHARAMICROSS") < 0)) __PYX_ERR(4, 1521, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1663, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1663, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1663, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1663, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -69757,42 +59080,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1521, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1663, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1523, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1523, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1523, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1523, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1665, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1665, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1665, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1665, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_458stream_CDLHIKKAKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -69805,62 +59127,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLHARAMICROSS", 0); + __Pyx_RefNannySetupContext("stream_CDLHIKKAKE", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1543, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1544, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1545, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1546, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1547, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1689, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1548, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1549, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1550, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1551, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLHARAMICROSS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLHIKKAKE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHARAMICROSS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1554, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIKKAKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1696, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1555, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -69870,7 +59187,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -69884,16 +59201,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_447stream_CDLHIGHWAVE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_446stream_CDLHIGHWAVE, " CDLHIGHWAVE(open, high, low, close)\n\n High-Wave Candle (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_447stream_CDLHIGHWAVE = {"stream_CDLHIGHWAVE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_447stream_CDLHIGHWAVE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_446stream_CDLHIGHWAVE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_447stream_CDLHIGHWAVE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -69914,9 +59231,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLHIGHWAVE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLHIKKAKEMOD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -69924,72 +59241,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1699, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1699, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1699, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1699, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1557, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1557, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, 1); __PYX_ERR(4, 1557, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1557, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, 2); __PYX_ERR(4, 1557, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1557, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, 3); __PYX_ERR(4, 1557, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLHIGHWAVE") < 0)) __PYX_ERR(4, 1557, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1699, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1699, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1699, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1699, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -69998,42 +59289,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1557, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1699, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1559, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1559, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1559, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1559, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1701, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1701, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1701, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1701, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -70046,62 +59336,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED Py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLHIGHWAVE", 0); + __Pyx_RefNannySetupContext("stream_CDLHIKKAKEMOD", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1579, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1580, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1581, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1723, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1582, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1583, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1725, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1584, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1585, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1586, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1587, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLHIGHWAVE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLHIKKAKEMOD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIGHWAVE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1590, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIKKAKEMOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1732, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1591, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1733, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -70111,7 +59396,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED Py /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -70125,16 +59410,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_449stream_CDLHIKKAKE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_448stream_CDLHIKKAKE, " CDLHIKKAKE(open, high, low, close)\n\n Hikkake Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_449stream_CDLHIKKAKE = {"stream_CDLHIKKAKE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_449stream_CDLHIKKAKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_448stream_CDLHIKKAKE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_449stream_CDLHIKKAKE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -70155,9 +59440,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLHIKKAKE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLHOMINGPIGEON (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -70165,72 +59450,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1735, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1735, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1735, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1735, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1593, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1593, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, 1); __PYX_ERR(4, 1593, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1593, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, 2); __PYX_ERR(4, 1593, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1593, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, 3); __PYX_ERR(4, 1593, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLHIKKAKE") < 0)) __PYX_ERR(4, 1593, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1735, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1735, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1735, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1735, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -70239,42 +59498,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1593, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1735, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1595, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1595, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1595, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1595, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1737, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1737, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1737, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1737, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -70287,62 +59545,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyO PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLHIKKAKE", 0); + __Pyx_RefNannySetupContext("stream_CDLHOMINGPIGEON", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1615, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1616, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1617, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1759, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1618, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1619, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1620, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1621, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1622, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1623, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLHIKKAKE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLHOMINGPIGEON((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIKKAKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1626, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHOMINGPIGEON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1627, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -70352,7 +59605,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyO /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -70366,16 +59619,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD, " CDLHIKKAKEMOD(open, high, low, close)\n\n Modified Hikkake Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD = {"stream_CDLHIKKAKEMOD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -70396,9 +59649,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLHIKKAKEMOD (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLIDENTICAL3CROWS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -70406,72 +59659,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1771, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1771, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1771, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1771, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1629, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1629, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, 1); __PYX_ERR(4, 1629, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1629, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, 2); __PYX_ERR(4, 1629, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1629, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, 3); __PYX_ERR(4, 1629, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLHIKKAKEMOD") < 0)) __PYX_ERR(4, 1629, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1771, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1771, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1771, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1771, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -70480,42 +59707,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1629, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1771, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1631, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1631, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1631, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1631, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1773, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1773, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1773, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1773, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -70528,62 +59754,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLHIKKAKEMOD", 0); + __Pyx_RefNannySetupContext("stream_CDLIDENTICAL3CROWS", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1651, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1652, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1653, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1654, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1655, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1797, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1656, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1657, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1799, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1658, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1659, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLHIKKAKEMOD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLIDENTICAL3CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIKKAKEMOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1662, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLIDENTICAL3CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1804, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1663, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1805, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -70593,7 +59814,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -70607,16 +59828,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_467stream_CDLINNECK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON, " CDLHOMINGPIGEON(open, high, low, close)\n\n Homing Pigeon (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON = {"stream_CDLHOMINGPIGEON", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON}; -static PyObject *__pyx_pw_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -70637,9 +59858,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLHOMINGPIGEON (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLINNECK (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -70647,72 +59868,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1807, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1807, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1807, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1807, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1665, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1665, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, 1); __PYX_ERR(4, 1665, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1665, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, 2); __PYX_ERR(4, 1665, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1665, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, 3); __PYX_ERR(4, 1665, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLHOMINGPIGEON") < 0)) __PYX_ERR(4, 1665, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1807, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1807, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1807, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1807, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -70721,42 +59916,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1665, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1807, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1667, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1667, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1667, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1667, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1809, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1809, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1809, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1809, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_466stream_CDLINNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -70769,62 +59963,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSE PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLHOMINGPIGEON", 0); + __Pyx_RefNannySetupContext("stream_CDLINNECK", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1687, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1829, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1688, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1689, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1690, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1691, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1833, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1692, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1693, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1835, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1694, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1695, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLHOMINGPIGEON((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLINNECK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHOMINGPIGEON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1698, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLINNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1840, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1699, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1841, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -70834,7 +60023,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSE /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -70848,16 +60037,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSE /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS, " CDLIDENTICAL3CROWS(open, high, low, close)\n\n Identical Three Crows (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS = {"stream_CDLIDENTICAL3CROWS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -70878,9 +60067,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLIDENTICAL3CROWS (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLINVERTEDHAMMER (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -70888,72 +60077,255 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1843, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1843, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1843, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1843, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1843, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1843, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1843, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1843, __pyx_L3_error) + } + __pyx_v_open = ((PyArrayObject *)values[0]); + __pyx_v_high = ((PyArrayObject *)values[1]); + __pyx_v_low = ((PyArrayObject *)values[2]); + __pyx_v_close = ((PyArrayObject *)values[3]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1843, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.stream_CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1845, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1845, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1845, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1845, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { + npy_intp __pyx_v_length; + TA_RetCode __pyx_v_retCode; + double *__pyx_v_open_data; + double *__pyx_v_high_data; + double *__pyx_v_low_data; + double *__pyx_v_close_data; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + int __pyx_v_outinteger; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_intp __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("stream_CDLINVERTEDHAMMER", 0); + __Pyx_INCREF((PyObject *)__pyx_v_open); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1869, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1871, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __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)-1L))) __PYX_ERR(5, 1873, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; + + __pyx_v_outinteger = 0; + + __pyx_v_retCode = TA_CDLINVERTEDHAMMER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLINVERTEDHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1876, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1877, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_open); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_471stream_CDLKICKING(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_open = 0; + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stream_CDLKICKING (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1701, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1879, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1701, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, 1); __PYX_ERR(4, 1701, __pyx_L3_error) - } + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1879, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1701, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, 2); __PYX_ERR(4, 1701, __pyx_L3_error) - } + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1879, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1701, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, 3); __PYX_ERR(4, 1701, __pyx_L3_error) - } + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1879, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLIDENTICAL3CROWS") < 0)) __PYX_ERR(4, 1701, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1879, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1879, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1879, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1879, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -70962,42 +60334,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1701, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1879, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1703, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1703, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1703, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1703, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1881, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1881, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1881, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1881, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_470stream_CDLKICKING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -71010,62 +60381,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UN PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLIDENTICAL3CROWS", 0); + __Pyx_RefNannySetupContext("stream_CDLKICKING", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1723, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1724, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1725, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1903, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1726, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1727, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1905, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1728, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1729, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1907, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1730, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1731, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLIDENTICAL3CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLKICKING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLIDENTICAL3CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1734, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLKICKING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1912, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1735, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -71075,7 +60441,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UN /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -71089,16 +60455,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UN /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_457stream_CDLINNECK(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_456stream_CDLINNECK, " CDLINNECK(open, high, low, close)\n\n In-Neck Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_457stream_CDLINNECK = {"stream_CDLINNECK", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_457stream_CDLINNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_456stream_CDLINNECK}; -static PyObject *__pyx_pw_5talib_7_ta_lib_457stream_CDLINNECK(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -71119,9 +60485,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLINNECK (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLKICKINGBYLENGTH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -71129,72 +60495,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1915, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1915, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1915, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1915, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1737, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1737, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, 1); __PYX_ERR(4, 1737, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1737, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, 2); __PYX_ERR(4, 1737, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1737, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, 3); __PYX_ERR(4, 1737, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLINNECK") < 0)) __PYX_ERR(4, 1737, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1915, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1915, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1915, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1915, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -71203,42 +60543,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1737, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1915, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1739, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1739, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1739, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1739, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1917, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1917, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1917, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1917, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -71251,62 +60590,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyOb PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLINNECK", 0); + __Pyx_RefNannySetupContext("stream_CDLKICKINGBYLENGTH", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1759, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1937, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1760, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1761, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1939, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1762, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1763, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1941, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1764, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1765, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1943, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1766, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1767, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLINNECK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLKICKINGBYLENGTH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLINNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1770, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLKICKINGBYLENGTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1948, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1771, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -71316,7 +60650,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyOb /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -71330,16 +60664,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER, " CDLINVERTEDHAMMER(open, high, low, close)\n\n Inverted Hammer (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER = {"stream_CDLINVERTEDHAMMER", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER}; -static PyObject *__pyx_pw_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -71360,9 +60694,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLINVERTEDHAMMER (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLLADDERBOTTOM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -71370,72 +60704,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1951, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1951, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1951, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1951, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1773, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1773, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, 1); __PYX_ERR(4, 1773, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1773, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, 2); __PYX_ERR(4, 1773, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1773, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, 3); __PYX_ERR(4, 1773, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLINVERTEDHAMMER") < 0)) __PYX_ERR(4, 1773, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1951, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1951, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1951, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1951, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -71444,42 +60752,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1773, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1951, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1775, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1775, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1775, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1775, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1953, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1953, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1953, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1953, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -71492,62 +60799,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNU PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLINVERTEDHAMMER", 0); + __Pyx_RefNannySetupContext("stream_CDLLADDERBOTTOM", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1795, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1796, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1797, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1975, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1798, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1799, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1977, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1800, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1801, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1802, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1803, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLINVERTEDHAMMER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLLADDERBOTTOM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLINVERTEDHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1806, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLADDERBOTTOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1984, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1807, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -71557,7 +60859,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNU /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -71571,16 +60873,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNU /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_461stream_CDLKICKING(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_460stream_CDLKICKING, " CDLKICKING(open, high, low, close)\n\n Kicking (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_461stream_CDLKICKING = {"stream_CDLKICKING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_461stream_CDLKICKING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_460stream_CDLKICKING}; -static PyObject *__pyx_pw_5talib_7_ta_lib_461stream_CDLKICKING(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -71601,9 +60903,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLKICKING (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLLONGLEGGEDDOJI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -71611,72 +60913,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1987, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1987, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1987, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1987, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1809, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1809, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, 1); __PYX_ERR(4, 1809, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1809, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, 2); __PYX_ERR(4, 1809, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1809, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, 3); __PYX_ERR(4, 1809, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLKICKING") < 0)) __PYX_ERR(4, 1809, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1987, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1987, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1987, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1987, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -71685,42 +60961,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1809, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1987, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1811, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1811, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1811, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1811, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1989, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1989, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1989, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1989, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -71733,62 +61008,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyO PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLKICKING", 0); + __Pyx_RefNannySetupContext("stream_CDLLONGLEGGEDDOJI", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1831, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1832, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1833, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2011, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1834, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1835, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1836, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1837, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1838, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1839, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLKICKING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLLONGLEGGEDDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLKICKING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1842, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLONGLEGGEDDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2020, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1843, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2021, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -71798,7 +61068,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyO /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -71812,16 +61082,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_479stream_CDLLONGLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH, " CDLKICKINGBYLENGTH(open, high, low, close)\n\n Kicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH = {"stream_CDLKICKINGBYLENGTH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -71842,9 +61112,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLKICKINGBYLENGTH (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLLONGLINE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -71852,72 +61122,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2023, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2023, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2023, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2023, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1845, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1845, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, 1); __PYX_ERR(4, 1845, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1845, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, 2); __PYX_ERR(4, 1845, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1845, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, 3); __PYX_ERR(4, 1845, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLKICKINGBYLENGTH") < 0)) __PYX_ERR(4, 1845, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2023, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2023, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2023, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2023, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -71926,42 +61170,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1845, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2023, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1847, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1847, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1847, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1847, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2025, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2025, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2025, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2025, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_478stream_CDLLONGLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -71974,62 +61217,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UN PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLKICKINGBYLENGTH", 0); + __Pyx_RefNannySetupContext("stream_CDLLONGLINE", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1867, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2045, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1868, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1869, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1870, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1871, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2049, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1872, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1873, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2051, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1874, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1875, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLKICKINGBYLENGTH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLLONGLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLKICKINGBYLENGTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1878, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLONGLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2056, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1879, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2057, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -72039,7 +61277,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UN /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -72053,16 +61291,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UN /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_481stream_CDLMARUBOZU(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM, " CDLLADDERBOTTOM(open, high, low, close)\n\n Ladder Bottom (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM = {"stream_CDLLADDERBOTTOM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -72083,9 +61321,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLLADDERBOTTOM (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLMARUBOZU (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -72093,72 +61331,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2059, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2059, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2059, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2059, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1881, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1881, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, 1); __PYX_ERR(4, 1881, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1881, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, 2); __PYX_ERR(4, 1881, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1881, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, 3); __PYX_ERR(4, 1881, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLLADDERBOTTOM") < 0)) __PYX_ERR(4, 1881, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2059, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2059, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2059, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2059, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -72167,42 +61379,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1881, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2059, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1883, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1883, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1883, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1883, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2061, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2061, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2061, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2061, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_480stream_CDLMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -72215,62 +61426,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSE PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLLADDERBOTTOM", 0); + __Pyx_RefNannySetupContext("stream_CDLMARUBOZU", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1903, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1904, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1905, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2083, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1906, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1907, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2085, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1908, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1909, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2087, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1910, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1911, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLLADDERBOTTOM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLMARUBOZU((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLADDERBOTTOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1914, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2092, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1915, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2093, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -72280,7 +61486,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSE /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -72294,16 +61500,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSE /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_483stream_CDLMATCHINGLOW(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI, " CDLLONGLEGGEDDOJI(open, high, low, close)\n\n Long Legged Doji (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI = {"stream_CDLLONGLEGGEDDOJI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -72324,9 +61530,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLLONGLEGGEDDOJI (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLMATCHINGLOW (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -72334,72 +61540,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2095, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2095, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2095, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2095, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1917, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1917, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, 1); __PYX_ERR(4, 1917, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1917, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, 2); __PYX_ERR(4, 1917, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1917, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, 3); __PYX_ERR(4, 1917, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLLONGLEGGEDDOJI") < 0)) __PYX_ERR(4, 1917, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2095, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2095, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2095, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2095, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -72408,42 +61588,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1917, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2095, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1919, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1919, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1919, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1919, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2097, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2097, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2097, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2097, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_482stream_CDLMATCHINGLOW(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -72456,62 +61635,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNU PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLLONGLEGGEDDOJI", 0); + __Pyx_RefNannySetupContext("stream_CDLMATCHINGLOW", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1939, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1940, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1941, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1942, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1943, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1944, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1945, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1946, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1947, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLLONGLEGGEDDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLMATCHINGLOW((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLONGLEGGEDDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1950, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMATCHINGLOW, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1951, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -72521,7 +61695,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNU /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -72535,16 +61709,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNU /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_469stream_CDLLONGLINE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_485stream_CDLMATHOLD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_468stream_CDLLONGLINE, " CDLLONGLINE(open, high, low, close)\n\n Long Line Candle (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_469stream_CDLLONGLINE = {"stream_CDLLONGLINE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_469stream_CDLLONGLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_468stream_CDLLONGLINE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_469stream_CDLLONGLINE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -72555,19 +61729,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; + double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLLONGLINE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLMATHOLD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -72575,116 +61750,105 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2131, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2131, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2131, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2131, __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(5, 2131, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1953, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1953, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, 1); __PYX_ERR(4, 1953, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1953, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, 2); __PYX_ERR(4, 1953, __pyx_L3_error) - } + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2131, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1953, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, 3); __PYX_ERR(4, 1953, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLLONGLINE") < 0)) __PYX_ERR(4, 1953, __pyx_L3_error) + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2131, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2131, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2131, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2131, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); + if (values[4]) { + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 2133, __pyx_L3_error) + } else { + __pyx_v_penetration = ((double)((double)0.5)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1953, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 2131, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1955, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1955, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1955, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1955, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2133, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2133, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2133, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2133, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_484stream_CDLMATHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -72697,62 +61861,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED Py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLLONGLINE", 0); + __Pyx_RefNannySetupContext("stream_CDLMATHOLD", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1975, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1976, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1977, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1978, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1979, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1980, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1981, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 1982, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 1983, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLLONGLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLMATHOLD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLONGLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1986, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMATHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1987, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -72762,7 +61921,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED Py /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -72776,16 +61935,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_471stream_CDLMARUBOZU(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_470stream_CDLMARUBOZU, " CDLMARUBOZU(open, high, low, close)\n\n Marubozu (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_471stream_CDLMARUBOZU = {"stream_CDLMARUBOZU", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_471stream_CDLMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_470stream_CDLMARUBOZU}; -static PyObject *__pyx_pw_5talib_7_ta_lib_471stream_CDLMARUBOZU(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -72796,19 +61955,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; + double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLMARUBOZU (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLMORNINGDOJISTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -72816,116 +61976,105 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2169, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2169, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2169, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2169, __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(5, 2169, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1989, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1989, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, 1); __PYX_ERR(4, 1989, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1989, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, 2); __PYX_ERR(4, 1989, __pyx_L3_error) - } + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2169, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 1989, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, 3); __PYX_ERR(4, 1989, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLMARUBOZU") < 0)) __PYX_ERR(4, 1989, __pyx_L3_error) + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2169, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2169, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2169, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2169, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); + if (values[4]) { + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 2171, __pyx_L3_error) + } else { + __pyx_v_penetration = ((double)((double)0.3)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1989, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 2169, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1991, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1991, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1991, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1991, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2171, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2171, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2171, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2171, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -72938,62 +62087,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED Py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLMARUBOZU", 0); + __Pyx_RefNannySetupContext("stream_CDLMORNINGDOJISTAR", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2011, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2012, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2013, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2195, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2014, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2015, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2016, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2017, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2018, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2019, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLMARUBOZU((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLMORNINGDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2022, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMORNINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2023, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -73003,7 +62147,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED Py /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -73017,16 +62161,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_473stream_CDLMATCHINGLOW(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_489stream_CDLMORNINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_472stream_CDLMATCHINGLOW, " CDLMATCHINGLOW(open, high, low, close)\n\n Matching Low (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_473stream_CDLMATCHINGLOW = {"stream_CDLMATCHINGLOW", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_473stream_CDLMATCHINGLOW, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_472stream_CDLMATCHINGLOW}; -static PyObject *__pyx_pw_5talib_7_ta_lib_473stream_CDLMATCHINGLOW(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -73037,19 +62181,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; + double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLMATCHINGLOW (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLMORNINGSTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -73057,116 +62202,105 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2207, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2207, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2207, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2207, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2207, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2025, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2025, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, 1); __PYX_ERR(4, 2025, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2025, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, 2); __PYX_ERR(4, 2025, __pyx_L3_error) - } + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2207, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2025, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, 3); __PYX_ERR(4, 2025, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLMATCHINGLOW") < 0)) __PYX_ERR(4, 2025, __pyx_L3_error) + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2207, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2207, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2207, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2207, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); + if (values[4]) { + __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 2209, __pyx_L3_error) + } else { + __pyx_v_penetration = ((double)((double)0.3)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2025, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 2207, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2027, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2027, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2027, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2027, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2209, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2209, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2209, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2209, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_488stream_CDLMORNINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -73179,62 +62313,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLMATCHINGLOW", 0); + __Pyx_RefNannySetupContext("stream_CDLMORNINGSTAR", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2047, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2048, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2049, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2233, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2050, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2051, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2052, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2053, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2054, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2055, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLMATCHINGLOW((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLMORNINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMATCHINGLOW, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2058, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMORNINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2059, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -73244,7 +62373,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -73258,16 +62387,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_475stream_CDLMATHOLD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_491stream_CDLONNECK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_474stream_CDLMATHOLD, " CDLMATHOLD(open, high, low, close[, penetration=?])\n\n Mat Hold (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.5\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_475stream_CDLMATHOLD = {"stream_CDLMATHOLD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_475stream_CDLMATHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_474stream_CDLMATHOLD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_475stream_CDLMATHOLD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -73278,20 +62407,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; - double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLMATHOLD (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLONNECK (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -73299,134 +62427,89 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2245, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2245, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2245, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2245, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2061, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2061, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, 1); __PYX_ERR(4, 2061, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2061, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, 2); __PYX_ERR(4, 2061, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2061, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, 3); __PYX_ERR(4, 2061, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2061, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLMATHOLD") < 0)) __PYX_ERR(4, 2061, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2245, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2245, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2245, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2245, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); - if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 2063, __pyx_L3_error) - } else { - __pyx_v_penetration = ((double)((double)0.5)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 2061, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2245, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2063, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2063, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2063, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2063, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2247, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2247, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2247, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2247, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_490stream_CDLONNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -73439,62 +62522,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyO PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLMATHOLD", 0); + __Pyx_RefNannySetupContext("stream_CDLONNECK", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2085, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2086, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2087, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2088, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2089, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2090, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2091, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2092, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2093, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLMATHOLD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLONNECK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMATHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2096, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLONNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2097, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -73504,7 +62582,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyO /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -73518,16 +62596,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_493stream_CDLPIERCING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR, " CDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\n Morning Doji Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR = {"stream_CDLMORNINGDOJISTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -73538,20 +62616,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; - double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLMORNINGDOJISTAR (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLPIERCING (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -73559,134 +62636,89 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2281, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2281, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2281, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2281, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2099, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2099, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, 1); __PYX_ERR(4, 2099, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2099, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, 2); __PYX_ERR(4, 2099, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2099, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, 3); __PYX_ERR(4, 2099, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2099, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLMORNINGDOJISTAR") < 0)) __PYX_ERR(4, 2099, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2281, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2281, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2281, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2281, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); - if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 2101, __pyx_L3_error) - } else { - __pyx_v_penetration = ((double)((double)0.3)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 2099, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2281, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2101, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2101, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2101, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2101, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2283, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2283, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2283, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2283, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_492stream_CDLPIERCING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -73699,62 +62731,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UN PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLMORNINGDOJISTAR", 0); + __Pyx_RefNannySetupContext("stream_CDLPIERCING", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2123, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2124, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2125, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2126, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2127, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2128, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2129, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2130, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2131, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLMORNINGDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLPIERCING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMORNINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2134, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLPIERCING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2135, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -73764,7 +62791,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UN /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -73778,16 +62805,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UN /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_479stream_CDLMORNINGSTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_478stream_CDLMORNINGSTAR, " CDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\n Morning Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Parameters:\n penetration: 0.3\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_479stream_CDLMORNINGSTAR = {"stream_CDLMORNINGSTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_479stream_CDLMORNINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_478stream_CDLMORNINGSTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_479stream_CDLMORNINGSTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -73798,20 +62825,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; - double __pyx_v_penetration; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLMORNINGSTAR (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLRICKSHAWMAN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -73819,134 +62845,89 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2317, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2317, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2317, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2317, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2137, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2137, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, 1); __PYX_ERR(4, 2137, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2137, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, 2); __PYX_ERR(4, 2137, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2137, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, 3); __PYX_ERR(4, 2137, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_penetration); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2137, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLMORNINGSTAR") < 0)) __PYX_ERR(4, 2137, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2317, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2317, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2317, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2317, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); - if (values[4]) { - __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 2139, __pyx_L3_error) - } else { - __pyx_v_penetration = ((double)((double)0.3)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 2137, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2317, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2139, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2139, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2139, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2139, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2319, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2319, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2319, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2319, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) { +static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -73959,62 +62940,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLMORNINGSTAR", 0); + __Pyx_RefNannySetupContext("stream_CDLRICKSHAWMAN", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2161, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2162, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2163, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2164, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2165, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2166, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2167, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2168, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2169, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLMORNINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLRICKSHAWMAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMORNINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2172, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLRICKSHAWMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2173, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -74024,7 +63000,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -74038,16 +63014,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_481stream_CDLONNECK(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_480stream_CDLONNECK, " CDLONNECK(open, high, low, close)\n\n On-Neck Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_481stream_CDLONNECK = {"stream_CDLONNECK", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_481stream_CDLONNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_480stream_CDLONNECK}; -static PyObject *__pyx_pw_5talib_7_ta_lib_481stream_CDLONNECK(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -74068,9 +63044,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLONNECK (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLRISEFALL3METHODS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -74078,72 +63054,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2353, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2353, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2353, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2353, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2175, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2175, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, 1); __PYX_ERR(4, 2175, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2175, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, 2); __PYX_ERR(4, 2175, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2175, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, 3); __PYX_ERR(4, 2175, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLONNECK") < 0)) __PYX_ERR(4, 2175, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2353, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2353, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2353, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2353, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -74152,42 +63102,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2175, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2353, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2177, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2177, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2177, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2177, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2355, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2355, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2355, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2355, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -74200,62 +63149,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyOb PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLONNECK", 0); + __Pyx_RefNannySetupContext("stream_CDLRISEFALL3METHODS", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2197, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2198, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2199, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2200, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2201, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2202, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2203, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2204, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2205, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLONNECK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLRISEFALL3METHODS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLONNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2208, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLRISEFALL3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2386, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2209, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -74265,7 +63209,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyOb /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -74279,16 +63223,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_483stream_CDLPIERCING(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_482stream_CDLPIERCING, " CDLPIERCING(open, high, low, close)\n\n Piercing Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_483stream_CDLPIERCING = {"stream_CDLPIERCING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_483stream_CDLPIERCING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_482stream_CDLPIERCING}; -static PyObject *__pyx_pw_5talib_7_ta_lib_483stream_CDLPIERCING(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -74309,9 +63253,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLPIERCING (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLSEPARATINGLINES (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -74319,72 +63263,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2389, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2389, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2389, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2389, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2211, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2211, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, 1); __PYX_ERR(4, 2211, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2211, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, 2); __PYX_ERR(4, 2211, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2211, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, 3); __PYX_ERR(4, 2211, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLPIERCING") < 0)) __PYX_ERR(4, 2211, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2389, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2389, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2389, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2389, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -74393,42 +63311,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2211, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2389, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2213, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2213, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2213, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2213, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2391, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2391, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2391, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2391, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -74441,62 +63358,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED Py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLPIERCING", 0); + __Pyx_RefNannySetupContext("stream_CDLSEPARATINGLINES", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2233, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2234, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2235, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2236, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2237, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2415, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2238, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2239, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2417, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2240, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2241, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLPIERCING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLSEPARATINGLINES((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLPIERCING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2244, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSEPARATINGLINES, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2245, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -74506,7 +63418,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED Py /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -74520,16 +63432,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN, " CDLRICKSHAWMAN(open, high, low, close)\n\n Rickshaw Man (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN = {"stream_CDLRICKSHAWMAN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -74550,9 +63462,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLRICKSHAWMAN (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLSHOOTINGSTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -74560,72 +63472,255 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2425, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2425, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2425, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2425, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2425, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2425, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2425, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2425, __pyx_L3_error) + } + __pyx_v_open = ((PyArrayObject *)values[0]); + __pyx_v_high = ((PyArrayObject *)values[1]); + __pyx_v_low = ((PyArrayObject *)values[2]); + __pyx_v_close = ((PyArrayObject *)values[3]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2425, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2427, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2427, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2427, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2427, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { + npy_intp __pyx_v_length; + TA_RetCode __pyx_v_retCode; + double *__pyx_v_open_data; + double *__pyx_v_high_data; + double *__pyx_v_low_data; + double *__pyx_v_close_data; + int __pyx_v_outbegidx; + int __pyx_v_outnbelement; + int __pyx_v_outinteger; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + npy_intp __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("stream_CDLSHOOTINGSTAR", 0); + __Pyx_INCREF((PyObject *)__pyx_v_open); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2453, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __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)-1L))) __PYX_ERR(5, 2455, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; + + __pyx_v_outinteger = 0; + + __pyx_v_retCode = TA_CDLSHOOTINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSHOOTINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2458, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_open); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_5talib_7_ta_lib_503stream_CDLSHORTLINE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +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)\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 +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_open = 0; + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stream_CDLSHORTLINE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2247, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2461, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2247, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, 1); __PYX_ERR(4, 2247, __pyx_L3_error) - } + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2461, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2247, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, 2); __PYX_ERR(4, 2247, __pyx_L3_error) - } + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2461, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2247, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, 3); __PYX_ERR(4, 2247, __pyx_L3_error) - } + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2461, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLRICKSHAWMAN") < 0)) __PYX_ERR(4, 2247, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2461, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2461, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2461, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2461, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -74634,42 +63729,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2247, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2461, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2249, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2249, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2249, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2249, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2463, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2463, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2463, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2463, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_502stream_CDLSHORTLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -74682,62 +63776,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLRICKSHAWMAN", 0); + __Pyx_RefNannySetupContext("stream_CDLSHORTLINE", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2269, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2270, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2271, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2272, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2273, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2274, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2275, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2276, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2277, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLRICKSHAWMAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLSHORTLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLRICKSHAWMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2280, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSHORTLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2281, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -74747,7 +63836,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -74761,16 +63850,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_505stream_CDLSPINNINGTOP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS, " CDLRISEFALL3METHODS(open, high, low, close)\n\n Rising/Falling Three Methods (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS = {"stream_CDLRISEFALL3METHODS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -74791,9 +63880,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLRISEFALL3METHODS (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLSPINNINGTOP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -74801,72 +63890,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2497, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2497, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2497, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2497, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2283, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2283, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, 1); __PYX_ERR(4, 2283, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2283, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, 2); __PYX_ERR(4, 2283, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2283, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, 3); __PYX_ERR(4, 2283, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLRISEFALL3METHODS") < 0)) __PYX_ERR(4, 2283, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2497, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2497, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2497, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2497, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -74875,42 +63938,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2283, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2497, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2285, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2285, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2285, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2285, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2499, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2499, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2499, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2499, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_504stream_CDLSPINNINGTOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -74923,62 +63985,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_U PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLRISEFALL3METHODS", 0); + __Pyx_RefNannySetupContext("stream_CDLSPINNINGTOP", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2305, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2519, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2306, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2307, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2308, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2309, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2310, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2311, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2525, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2312, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2313, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLRISEFALL3METHODS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLSPINNINGTOP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLRISEFALL3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2316, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSPINNINGTOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2317, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -74988,7 +64045,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_U /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -75002,16 +64059,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_U /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES, " CDLSEPARATINGLINES(open, high, low, close)\n\n Separating Lines (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES = {"stream_CDLSEPARATINGLINES", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES}; -static PyObject *__pyx_pw_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -75032,9 +64089,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLSEPARATINGLINES (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLSTALLEDPATTERN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -75042,72 +64099,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2533, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2533, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2533, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2533, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2319, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2319, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, 1); __PYX_ERR(4, 2319, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2319, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, 2); __PYX_ERR(4, 2319, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2319, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, 3); __PYX_ERR(4, 2319, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLSEPARATINGLINES") < 0)) __PYX_ERR(4, 2319, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2533, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2533, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2533, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2533, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -75116,42 +64147,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2319, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2533, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2321, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2321, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2321, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2321, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2535, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2535, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2535, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2535, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -75164,62 +64194,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UN PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLSEPARATINGLINES", 0); + __Pyx_RefNannySetupContext("stream_CDLSTALLEDPATTERN", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2341, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2342, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2343, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2344, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2345, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2346, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2347, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2561, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2348, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2349, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLSEPARATINGLINES((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLSTALLEDPATTERN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSEPARATINGLINES, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2352, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSTALLEDPATTERN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2353, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -75229,7 +64254,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UN /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -75243,16 +64268,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UN /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR, " CDLSHOOTINGSTAR(open, high, low, close)\n\n Shooting Star (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR = {"stream_CDLSHOOTINGSTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -75273,9 +64298,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLSHOOTINGSTAR (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLSTICKSANDWICH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -75283,72 +64308,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2569, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2569, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2569, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2569, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2355, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2355, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, 1); __PYX_ERR(4, 2355, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2355, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, 2); __PYX_ERR(4, 2355, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2355, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, 3); __PYX_ERR(4, 2355, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLSHOOTINGSTAR") < 0)) __PYX_ERR(4, 2355, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2569, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2569, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2569, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2569, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -75357,42 +64356,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2355, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2569, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2357, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2357, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2357, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2357, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2571, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2571, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2571, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2571, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -75405,62 +64403,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSE PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLSHOOTINGSTAR", 0); + __Pyx_RefNannySetupContext("stream_CDLSTICKSANDWICH", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2377, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2378, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2379, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2380, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2381, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2382, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2383, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2597, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2384, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2385, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLSHOOTINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLSTICKSANDWICH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSHOOTINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2388, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSTICKSANDWICH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2389, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2603, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -75470,7 +64463,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSE /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -75484,16 +64477,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSE /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_493stream_CDLSHORTLINE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_511stream_CDLTAKURI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_492stream_CDLSHORTLINE, " CDLSHORTLINE(open, high, low, close)\n\n Short Line Candle (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_493stream_CDLSHORTLINE = {"stream_CDLSHORTLINE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_493stream_CDLSHORTLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_492stream_CDLSHORTLINE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_493stream_CDLSHORTLINE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -75514,9 +64507,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLSHORTLINE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLTAKURI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -75524,72 +64517,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2605, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2605, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2605, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2605, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2391, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2391, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, 1); __PYX_ERR(4, 2391, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2391, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, 2); __PYX_ERR(4, 2391, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2391, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, 3); __PYX_ERR(4, 2391, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLSHORTLINE") < 0)) __PYX_ERR(4, 2391, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2605, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2605, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2605, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2605, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -75598,42 +64565,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2391, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2605, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2393, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2393, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2393, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2393, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2607, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2607, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2607, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2607, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_510stream_CDLTAKURI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -75646,62 +64612,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED P PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLSHORTLINE", 0); + __Pyx_RefNannySetupContext("stream_CDLTAKURI", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2413, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2627, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2414, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2415, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2416, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2417, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2418, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2419, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2420, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2421, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLSHORTLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLTAKURI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSHORTLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2424, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTAKURI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2638, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2425, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2639, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -75711,7 +64672,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED P /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -75725,16 +64686,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_495stream_CDLSPINNINGTOP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_513stream_CDLTASUKIGAP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_494stream_CDLSPINNINGTOP, " CDLSPINNINGTOP(open, high, low, close)\n\n Spinning Top (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_495stream_CDLSPINNINGTOP = {"stream_CDLSPINNINGTOP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_495stream_CDLSPINNINGTOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_494stream_CDLSPINNINGTOP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_495stream_CDLSPINNINGTOP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -75755,9 +64716,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLSPINNINGTOP (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLTASUKIGAP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -75765,72 +64726,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2641, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2641, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2641, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2641, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2427, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2427, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, 1); __PYX_ERR(4, 2427, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2427, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, 2); __PYX_ERR(4, 2427, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2427, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, 3); __PYX_ERR(4, 2427, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLSPINNINGTOP") < 0)) __PYX_ERR(4, 2427, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2641, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2641, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2641, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2641, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -75839,42 +64774,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2427, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2641, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2429, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2429, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2429, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2429, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2643, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2643, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2643, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2643, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_512stream_CDLTASUKIGAP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -75887,62 +64821,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLSPINNINGTOP", 0); + __Pyx_RefNannySetupContext("stream_CDLTASUKIGAP", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2449, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2450, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2451, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2665, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2452, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2453, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2454, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2455, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2669, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2456, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2457, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLSPINNINGTOP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLTASUKIGAP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSPINNINGTOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2460, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTASUKIGAP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2461, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -75952,7 +64881,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -75966,16 +64895,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_515stream_CDLTHRUSTING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN, " CDLSTALLEDPATTERN(open, high, low, close)\n\n Stalled Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN = {"stream_CDLSTALLEDPATTERN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -75996,9 +64925,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLSTALLEDPATTERN (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLTHRUSTING (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -76006,72 +64935,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2677, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2677, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2463, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2463, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, 1); __PYX_ERR(4, 2463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2463, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, 2); __PYX_ERR(4, 2463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2463, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, 3); __PYX_ERR(4, 2463, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLSTALLEDPATTERN") < 0)) __PYX_ERR(4, 2463, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2677, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2677, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2677, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2677, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -76080,42 +64983,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2463, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2677, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2465, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2465, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2465, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2465, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2679, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2679, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2679, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2679, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_514stream_CDLTHRUSTING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -76128,62 +65030,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNU PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLSTALLEDPATTERN", 0); + __Pyx_RefNannySetupContext("stream_CDLTHRUSTING", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2485, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2486, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2487, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2701, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2488, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2489, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2490, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2491, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2492, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2493, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLSTALLEDPATTERN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLTHRUSTING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSTALLEDPATTERN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2496, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTHRUSTING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2710, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2497, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -76193,7 +65090,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNU /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -76207,16 +65104,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNU /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_517stream_CDLTRISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH, " CDLSTICKSANDWICH(open, high, low, close)\n\n Stick Sandwich (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH = {"stream_CDLSTICKSANDWICH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -76237,9 +65134,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLSTICKSANDWICH (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLTRISTAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -76247,72 +65144,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2713, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2713, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2713, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2713, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2499, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2499, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, 1); __PYX_ERR(4, 2499, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2499, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, 2); __PYX_ERR(4, 2499, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2499, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, 3); __PYX_ERR(4, 2499, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLSTICKSANDWICH") < 0)) __PYX_ERR(4, 2499, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2713, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2713, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2713, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2713, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -76321,42 +65192,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2499, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2713, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2501, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2501, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2501, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2501, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2715, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2715, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2715, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2715, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_516stream_CDLTRISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -76369,62 +65239,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUS PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLSTICKSANDWICH", 0); + __Pyx_RefNannySetupContext("stream_CDLTRISTAR", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2521, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2522, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2523, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2524, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2525, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2526, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2527, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2741, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2528, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2529, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLSTICKSANDWICH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLTRISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSTICKSANDWICH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2532, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTRISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2533, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -76434,7 +65299,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUS /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -76448,16 +65313,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUS /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_501stream_CDLTAKURI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_500stream_CDLTAKURI, " CDLTAKURI(open, high, low, close)\n\n Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_501stream_CDLTAKURI = {"stream_CDLTAKURI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_501stream_CDLTAKURI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_500stream_CDLTAKURI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_501stream_CDLTAKURI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -76478,9 +65343,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLTAKURI (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLUNIQUE3RIVER (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -76488,72 +65353,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2749, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2749, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2535, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2535, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, 1); __PYX_ERR(4, 2535, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2535, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, 2); __PYX_ERR(4, 2535, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2535, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, 3); __PYX_ERR(4, 2535, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLTAKURI") < 0)) __PYX_ERR(4, 2535, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2749, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2749, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2749, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2749, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -76562,42 +65401,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2535, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2749, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2537, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2537, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2537, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2537, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2751, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2751, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2751, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2751, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -76610,62 +65448,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyOb PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLTAKURI", 0); + __Pyx_RefNannySetupContext("stream_CDLUNIQUE3RIVER", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2557, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2771, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2558, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2559, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2773, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2560, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2561, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2775, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2562, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2563, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2777, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2564, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2565, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLTAKURI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLUNIQUE3RIVER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTAKURI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2568, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLUNIQUE3RIVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2569, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2783, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -76675,7 +65508,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyOb /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -76689,16 +65522,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_503stream_CDLTASUKIGAP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_502stream_CDLTASUKIGAP, " CDLTASUKIGAP(open, high, low, close)\n\n Tasuki Gap (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_503stream_CDLTASUKIGAP = {"stream_CDLTASUKIGAP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_503stream_CDLTASUKIGAP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_502stream_CDLTASUKIGAP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_503stream_CDLTASUKIGAP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -76719,9 +65552,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLTASUKIGAP (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLUPSIDEGAP2CROWS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -76729,72 +65562,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2785, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2785, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2785, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2785, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2571, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2571, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, 1); __PYX_ERR(4, 2571, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2571, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, 2); __PYX_ERR(4, 2571, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2571, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, 3); __PYX_ERR(4, 2571, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLTASUKIGAP") < 0)) __PYX_ERR(4, 2571, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2785, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2785, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2785, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2785, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -76803,42 +65610,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2571, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2785, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2573, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2573, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2573, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2573, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2787, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2787, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2787, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2787, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -76851,62 +65657,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED P PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLTASUKIGAP", 0); + __Pyx_RefNannySetupContext("stream_CDLUPSIDEGAP2CROWS", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2593, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2807, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2594, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2595, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2809, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2596, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2597, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2811, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2598, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2599, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2600, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2601, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLTASUKIGAP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLUPSIDEGAP2CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTASUKIGAP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2604, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLUPSIDEGAP2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2605, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -76916,7 +65717,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED P /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -76930,16 +65731,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_505stream_CDLTHRUSTING(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_504stream_CDLTHRUSTING, " CDLTHRUSTING(open, high, low, close)\n\n Thrusting Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_505stream_CDLTHRUSTING = {"stream_CDLTHRUSTING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_505stream_CDLTHRUSTING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_504stream_CDLTHRUSTING}; -static PyObject *__pyx_pw_5talib_7_ta_lib_505stream_CDLTHRUSTING(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -76960,9 +65761,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLTHRUSTING (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CDLXSIDEGAP3METHODS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -76970,72 +65771,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2821, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2821, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2821, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2821, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2607, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2607, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, 1); __PYX_ERR(4, 2607, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2607, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, 2); __PYX_ERR(4, 2607, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2607, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, 3); __PYX_ERR(4, 2607, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLTHRUSTING") < 0)) __PYX_ERR(4, 2607, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2821, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2821, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2821, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2821, __pyx_L3_error) } __pyx_v_open = ((PyArrayObject *)values[0]); __pyx_v_high = ((PyArrayObject *)values[1]); @@ -77044,42 +65819,41 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2607, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2821, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2609, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2609, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2609, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2609, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2823, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2823, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2823, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2823, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_open_data; @@ -77092,62 +65866,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED P PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLTHRUSTING", 0); + __Pyx_RefNannySetupContext("stream_CDLXSIDEGAP3METHODS", 0); __Pyx_INCREF((PyObject *)__pyx_v_open); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2629, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2630, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2631, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2632, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2633, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2847, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2634, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2635, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2636, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2637, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CDLTHRUSTING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CDLXSIDEGAP3METHODS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTHRUSTING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2640, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLXSIDEGAP3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2854, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2641, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -77157,7 +65926,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED P /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); @@ -77171,39 +65940,36 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_507stream_CDLTRISTAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_525stream_CEIL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_506stream_CDLTRISTAR, " CDLTRISTAR(open, high, low, close)\n\n Tristar Pattern (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_507stream_CDLTRISTAR = {"stream_CDLTRISTAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_507stream_CDLTRISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_506stream_CDLTRISTAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_507stream_CDLTRISTAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_open = 0; - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; - PyArrayObject *__pyx_v_close = 0; + PyArrayObject *__pyx_v_real = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLTRISTAR (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CEIL (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -77211,184 +65977,99 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2857, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2643, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2643, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, 1); __PYX_ERR(4, 2643, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2643, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, 2); __PYX_ERR(4, 2643, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2643, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, 3); __PYX_ERR(4, 2643, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLTRISTAR") < 0)) __PYX_ERR(4, 2643, __pyx_L3_error) + const Py_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) + 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) } } - } else if (unlikely(__pyx_nargs != 4)) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2857, __pyx_L3_error) } - __pyx_v_open = ((PyArrayObject *)values[0]); - __pyx_v_high = ((PyArrayObject *)values[1]); - __pyx_v_low = ((PyArrayObject *)values[2]); - __pyx_v_close = ((PyArrayObject *)values[3]); + __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2643, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CEIL", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 2857, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2645, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2645, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2645, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2645, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 2859, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_524stream_CEIL(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_open_data; - double *__pyx_v_high_data; - double *__pyx_v_low_data; - double *__pyx_v_close_data; + double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - int __pyx_v_outinteger; + double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLTRISTAR", 0); - __Pyx_INCREF((PyObject *)__pyx_v_open); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - __Pyx_INCREF((PyObject *)__pyx_v_close); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2665, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2666, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2667, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2668, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2669, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2670, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __Pyx_RefNannySetupContext("stream_CEIL", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2671, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2672, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2673, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outinteger = 0; + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_CDLTRISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CEIL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTRISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2676, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CEIL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2677, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -77398,13 +66079,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(CYTHON_UNUSED PyO /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_open); - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); - __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XDECREF((PyObject *)__pyx_v_real); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -77412,39 +66090,37 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_527stream_CMO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER, " CDLUNIQUE3RIVER(open, high, low, close)\n\n Unique 3 River (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER = {"stream_CDLUNIQUE3RIVER", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER}; -static PyObject *__pyx_pw_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_open = 0; - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; - PyArrayObject *__pyx_v_close = 0; + PyArrayObject *__pyx_v_real = 0; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLUNIQUE3RIVER (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CMO (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -77452,184 +66128,115 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2884, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2884, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2679, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2679, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, 1); __PYX_ERR(4, 2679, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2679, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, 2); __PYX_ERR(4, 2679, __pyx_L3_error) - } + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2884, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2679, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, 3); __PYX_ERR(4, 2679, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLUNIQUE3RIVER") < 0)) __PYX_ERR(4, 2679, __pyx_L3_error) + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2884, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; + } + __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 2886, __pyx_L3_error) } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + __pyx_v_timeperiod = ((int)((int)-2147483648)); } - __pyx_v_open = ((PyArrayObject *)values[0]); - __pyx_v_high = ((PyArrayObject *)values[1]); - __pyx_v_low = ((PyArrayObject *)values[2]); - __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2679, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CMO", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 2884, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CMO", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2681, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2681, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2681, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2681, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 2886, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_526stream_CMO(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_open_data; - double *__pyx_v_high_data; - double *__pyx_v_low_data; - double *__pyx_v_close_data; + double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - int __pyx_v_outinteger; + double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLUNIQUE3RIVER", 0); - __Pyx_INCREF((PyObject *)__pyx_v_open); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - __Pyx_INCREF((PyObject *)__pyx_v_close); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2701, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2702, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2703, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2704, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2705, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2706, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __Pyx_RefNannySetupContext("stream_CMO", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2707, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2905, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2708, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2709, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outinteger = 0; + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_CDLUNIQUE3RIVER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CMO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLUNIQUE3RIVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2712, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CMO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2910, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2713, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2911, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -77639,13 +66246,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(CYTHON_UNUSE /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CMO", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_open); - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); - __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XDECREF((PyObject *)__pyx_v_real); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -77653,39 +66257,38 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(CYTHON_UNUSE /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_529stream_CORREL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS, " CDLUPSIDEGAP2CROWS(open, high, low, close)\n\n Upside Gap Two Crows (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS = {"stream_CDLUPSIDEGAP2CROWS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_open = 0; - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; - PyArrayObject *__pyx_v_close = 0; + PyArrayObject *__pyx_v_real0 = 0; + PyArrayObject *__pyx_v_real1 = 0; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLUPSIDEGAP2CROWS (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_CORREL (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -77693,184 +66296,134 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2913, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2913, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2913, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2715, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2715, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, 1); __PYX_ERR(4, 2715, __pyx_L3_error) - } + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2913, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2715, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, 2); __PYX_ERR(4, 2715, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2715, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, 3); __PYX_ERR(4, 2715, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLUPSIDEGAP2CROWS") < 0)) __PYX_ERR(4, 2715, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2913, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2913, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; + } + __pyx_v_real0 = ((PyArrayObject *)values[0]); + __pyx_v_real1 = ((PyArrayObject *)values[1]); + if (values[2]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 2915, __pyx_L3_error) } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + __pyx_v_timeperiod = ((int)((int)-2147483648)); } - __pyx_v_open = ((PyArrayObject *)values[0]); - __pyx_v_high = ((PyArrayObject *)values[1]); - __pyx_v_low = ((PyArrayObject *)values[2]); - __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2715, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_CORREL", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 2913, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2717, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2717, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2717, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2717, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 2915, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 2915, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_528stream_CORREL(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_open_data; - double *__pyx_v_high_data; - double *__pyx_v_low_data; - double *__pyx_v_close_data; + double *__pyx_v_real0_data; + double *__pyx_v_real1_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - int __pyx_v_outinteger; + double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLUPSIDEGAP2CROWS", 0); - __Pyx_INCREF((PyObject *)__pyx_v_open); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - __Pyx_INCREF((PyObject *)__pyx_v_close); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2737, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2738, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2739, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2740, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __Pyx_RefNannySetupContext("stream_CORREL", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real0); + __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2741, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2936, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2742, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2743, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2938, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2744, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2745, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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_outinteger = 0; + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_CDLUPSIDEGAP2CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_CORREL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLUPSIDEGAP2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2748, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CORREL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2943, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2749, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2944, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -77880,13 +66433,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(CYTHON_UN /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_open); - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); - __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XDECREF((PyObject *)__pyx_v_real0); + __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -77894,39 +66445,36 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(CYTHON_UN /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_531stream_COS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS, " CDLXSIDEGAP3METHODS(open, high, low, close)\n\n Upside/Downside Gap Three Methods (Pattern Recognition)\n\n Inputs:\n prices: ['open', 'high', 'low', 'close']\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS = {"stream_CDLXSIDEGAP3METHODS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_open = 0; - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; - PyArrayObject *__pyx_v_close = 0; + PyArrayObject *__pyx_v_real = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CDLXSIDEGAP3METHODS (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_COS (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -77934,184 +66482,99 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2946, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2751, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2751, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, 1); __PYX_ERR(4, 2751, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2751, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, 2); __PYX_ERR(4, 2751, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2751, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, 3); __PYX_ERR(4, 2751, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CDLXSIDEGAP3METHODS") < 0)) __PYX_ERR(4, 2751, __pyx_L3_error) + const Py_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) + 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) } } - } else if (unlikely(__pyx_nargs != 4)) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2946, __pyx_L3_error) } - __pyx_v_open = ((PyArrayObject *)values[0]); - __pyx_v_high = ((PyArrayObject *)values[1]); - __pyx_v_low = ((PyArrayObject *)values[2]); - __pyx_v_close = ((PyArrayObject *)values[3]); + __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2751, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_COS", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 2946, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_COS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2753, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2753, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2753, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2753, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 2948, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_530stream_COS(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_open_data; - double *__pyx_v_high_data; - double *__pyx_v_low_data; - double *__pyx_v_close_data; + double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - int __pyx_v_outinteger; + double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CDLXSIDEGAP3METHODS", 0); - __Pyx_INCREF((PyObject *)__pyx_v_open); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - __Pyx_INCREF((PyObject *)__pyx_v_close); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2773, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2774, __pyx_L1_error) - __pyx_v_open_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2775, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2776, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2777, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2778, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __Pyx_RefNannySetupContext("stream_COS", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2779, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2965, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2780, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2781, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outinteger = 0; + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_CDLXSIDEGAP3METHODS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_COS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLXSIDEGAP3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2784, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_COS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2970, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2785, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -78121,13 +66584,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(CYTHON_U /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_COS", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_open); - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); - __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XDECREF((PyObject *)__pyx_v_real); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -78135,16 +66595,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(CYTHON_U /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_515stream_CEIL(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_533stream_COSH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_514stream_CEIL, " CEIL(real)\n\n Vector Ceil (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_515stream_CEIL = {"stream_CEIL", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_515stream_CEIL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_514stream_CEIL}; -static PyObject *__pyx_pw_5talib_7_ta_lib_515stream_CEIL(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -78162,9 +66622,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CEIL (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_COSH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -78172,71 +66632,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2973, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2787, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CEIL") < 0)) __PYX_ERR(4, 2787, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2973, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CEIL", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 2787, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_COSH", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 2973, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_COSH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2789, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_514stream_CEIL(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 2975, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_532stream_COSH(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -78246,35 +66700,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CEIL(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CEIL", 0); + __Pyx_RefNannySetupContext("stream_COSH", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2806, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2992, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2807, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2808, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_CEIL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_COSH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CEIL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2811, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_COSH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2812, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2998, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -78284,7 +66734,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CEIL(CYTHON_UNUSED PyObject /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_COSH", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -78295,16 +66745,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CEIL(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_517stream_CMO(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_535stream_DEMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_516stream_CMO, " CMO(real[, timeperiod=?])\n\n Chande Momentum Oscillator (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_517stream_CMO = {"stream_CMO", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_517stream_CMO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_516stream_CMO}; -static PyObject *__pyx_pw_5talib_7_ta_lib_517stream_CMO(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -78323,9 +66773,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CMO (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_DEMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -78333,89 +66783,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3000, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3000, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2814, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2814, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CMO") < 0)) __PYX_ERR(4, 2814, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3000, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3000, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2816, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3002, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CMO", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 2814, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_DEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3000, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CMO", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2816, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_516stream_CMO(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3002, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_534stream_DEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_534stream_DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -78425,35 +66867,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CMO(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CMO", 0); + __Pyx_RefNannySetupContext("stream_DEMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2835, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3021, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2836, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2837, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_CMO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_DEMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CMO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2840, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3026, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2841, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3027, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -78463,7 +66901,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CMO(CYTHON_UNUSED PyObject * /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CMO", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -78474,16 +66912,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CMO(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_519stream_CORREL(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_537stream_DIV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_518stream_CORREL, " CORREL(real0, real1[, timeperiod=?])\n\n Pearson's Correlation Coefficient (r) (Statistic Functions)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_519stream_CORREL = {"stream_CORREL", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_519stream_CORREL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_518stream_CORREL}; -static PyObject *__pyx_pw_5talib_7_ta_lib_519stream_CORREL(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -78492,20 +66930,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds ) { PyArrayObject *__pyx_v_real0 = 0; PyArrayObject *__pyx_v_real1 = 0; - int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_CORREL (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_DIV (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -78513,104 +66950,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3029, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3029, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2843, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2843, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_CORREL", 0, 2, 3, 1); __PYX_ERR(4, 2843, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2843, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_CORREL") < 0)) __PYX_ERR(4, 2843, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3029, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3029, __pyx_L3_error) } __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); - if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2845, __pyx_L3_error) - } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_CORREL", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 2843, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_DIV", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 3029, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_DIV", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 2845, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 2845, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_518stream_CORREL(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 3031, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 3031, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_536stream_DIV(__pyx_self, __pyx_v_real0, __pyx_v_real1); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real0_data; @@ -78621,44 +67027,41 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CORREL(CYTHON_UNUSED PyObjec PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_CORREL", 0); + __Pyx_RefNannySetupContext("stream_DIV", 0); __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2866, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3050, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2867, __pyx_L1_error) - __pyx_v_real0_data = ((double *)__pyx_t_2); + __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2868, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3052, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2869, __pyx_L1_error) - __pyx_v_real1_data = ((double *)__pyx_t_2); + __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2870, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_CORREL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_DIV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CORREL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2873, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DIV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3057, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2874, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3058, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -78668,7 +67071,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CORREL(CYTHON_UNUSED PyObjec /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_DIV", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real0); @@ -78680,36 +67083,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CORREL(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_521stream_COS(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_539stream_DX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_520stream_COS, " COS(real)\n\n Vector Trigonometric Cos (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_521stream_COS = {"stream_COS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_521stream_COS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_520stream_COS}; -static PyObject *__pyx_pw_5talib_7_ta_lib_521stream_COS(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_real = 0; + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_COS (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_DX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -78717,269 +67123,151 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3060, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3060, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3060, __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(5, 3060, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2876, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + const Py_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) + 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) } } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_COS") < 0)) __PYX_ERR(4, 2876, __pyx_L3_error) + } else { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3060, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3060, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3060, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3060, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; + } + __pyx_v_high = ((PyArrayObject *)values[0]); + __pyx_v_low = ((PyArrayObject *)values[1]); + __pyx_v_close = ((PyArrayObject *)values[2]); + if (values[3]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3062, __pyx_L3_error) } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + __pyx_v_timeperiod = ((int)((int)-2147483648)); } - __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_COS", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 2876, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 3060, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_COS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_DX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2878, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_520stream_COS(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 3062, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 3062, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 3062, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_538stream_DX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_real_data; + double *__pyx_v_high_data; + double *__pyx_v_low_data; + double *__pyx_v_close_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_COS", 0); - __Pyx_INCREF((PyObject *)__pyx_v_real); + __Pyx_RefNannySetupContext("stream_DX", 0); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2895, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3083, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2896, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); - - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2897, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); - - __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - - __pyx_v_retCode = TA_COS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_COS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2900, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2901, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3085, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - goto __pyx_L0; - - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_COS", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_real); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); -/* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_523stream_COSH(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_522stream_COSH, " COSH(real)\n\n Vector Trigonometric Cosh (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_523stream_COSH = {"stream_COSH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_523stream_COSH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_522stream_COSH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_523stream_COSH(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyArrayObject *__pyx_v_real = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_COSH (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2903, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_COSH") < 0)) __PYX_ERR(4, 2903, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_real = ((PyArrayObject *)values[0]); - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_COSH", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 2903, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("talib._ta_lib.stream_COSH", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2905, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_522stream_COSH(__pyx_self, __pyx_v_real); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { - npy_intp __pyx_v_length; - TA_RetCode __pyx_v_retCode; - double *__pyx_v_real_data; - int __pyx_v_outbegidx; - int __pyx_v_outnbelement; - double __pyx_v_outreal; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_COSH", 0); - __Pyx_INCREF((PyObject *)__pyx_v_real); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2922, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3087, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2923, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2924, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[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)-1L))) __PYX_ERR(5, 3089, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_COSH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_DX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_COSH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2927, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3092, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2928, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3093, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -78989,10 +67277,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_COSH(CYTHON_UNUSED PyObject /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_COSH", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_DX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_real); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -79000,16 +67290,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_COSH(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_525stream_DEMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_541stream_EMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_524stream_DEMA, " DEMA(real[, timeperiod=?])\n\n Double Exponential Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_525stream_DEMA = {"stream_DEMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_525stream_DEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_524stream_DEMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_525stream_DEMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -79028,9 +67318,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_DEMA (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_EMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -79038,89 +67328,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3095, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3095, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2930, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2930, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_DEMA") < 0)) __PYX_ERR(4, 2930, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3095, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3095, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2932, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3097, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_DEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 2930, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_EMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3095, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_EMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2932, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_524stream_DEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3097, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_540stream_EMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -79130,35 +67412,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_DEMA(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_DEMA", 0); + __Pyx_RefNannySetupContext("stream_EMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2951, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2952, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2953, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_DEMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_EMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2956, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_EMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2957, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -79168,7 +67446,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_DEMA(CYTHON_UNUSED PyObject /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_EMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -79179,37 +67457,36 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_DEMA(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_527stream_DIV(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_543stream_EXP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_526stream_DIV, " DIV(real0, real1)\n\n Vector Arithmetic Div (Math Operators)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_527stream_DIV = {"stream_DIV", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_527stream_DIV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_526stream_DIV}; -static PyObject *__pyx_pw_5talib_7_ta_lib_527stream_DIV(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_real0 = 0; - PyArrayObject *__pyx_v_real1 = 0; + PyArrayObject *__pyx_v_real = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_DIV (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_EXP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -79217,134 +67494,99 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3124, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2959, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2959, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_DIV", 1, 2, 2, 1); __PYX_ERR(4, 2959, __pyx_L3_error) - } + const Py_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) + 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) } } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_DIV") < 0)) __PYX_ERR(4, 2959, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3124, __pyx_L3_error) } - __pyx_v_real0 = ((PyArrayObject *)values[0]); - __pyx_v_real1 = ((PyArrayObject *)values[1]); + __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_DIV", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 2959, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_EXP", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3124, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_DIV", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_EXP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 2961, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 2961, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_526stream_DIV(__pyx_self, __pyx_v_real0, __pyx_v_real1); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3126, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_542stream_EXP(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { +static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_real0_data; - double *__pyx_v_real1_data; + double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_DIV", 0); - __Pyx_INCREF((PyObject *)__pyx_v_real0); - __Pyx_INCREF((PyObject *)__pyx_v_real1); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2980, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2981, __pyx_L1_error) - __pyx_v_real0_data = ((double *)__pyx_t_2); + __Pyx_RefNannySetupContext("stream_EXP", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2982, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 2983, __pyx_L1_error) - __pyx_v_real1_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 2984, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_DIV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_EXP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DIV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2987, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_EXP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2988, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -79354,11 +67596,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_DIV(CYTHON_UNUSED PyObject * /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_DIV", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_EXP", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_real0); - __Pyx_XDECREF((PyObject *)__pyx_v_real1); + __Pyx_XDECREF((PyObject *)__pyx_v_real); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -79366,39 +67607,36 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_DIV(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_529stream_DX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_545stream_FLOOR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_528stream_DX, " DX(high, low, close[, timeperiod=?])\n\n Directional Movement Index (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_529stream_DX = {"stream_DX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_529stream_DX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_528stream_DX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_529stream_DX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; - PyArrayObject *__pyx_v_close = 0; - int __pyx_v_timeperiod; + PyArrayObject *__pyx_v_real = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_DX (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_FLOOR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -79406,177 +67644,99 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3151, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2990, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2990, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, 1); __PYX_ERR(4, 2990, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2990, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, 2); __PYX_ERR(4, 2990, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 2990, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_DX") < 0)) __PYX_ERR(4, 2990, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 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, "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) } } - } - __pyx_v_high = ((PyArrayObject *)values[0]); - __pyx_v_low = ((PyArrayObject *)values[1]); - __pyx_v_close = ((PyArrayObject *)values[2]); - if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2992, __pyx_L3_error) + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3151, __pyx_L3_error) } + __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 2990, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_FLOOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3151, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_DX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2992, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2992, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2992, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_528stream_DX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3153, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_544stream_FLOOR(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_high_data; - double *__pyx_v_low_data; - double *__pyx_v_close_data; + double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_DX", 0); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - __Pyx_INCREF((PyObject *)__pyx_v_close); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3013, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3014, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3015, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3016, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __Pyx_RefNannySetupContext("stream_FLOOR", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3017, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3018, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 3019, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_DX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_FLOOR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3022, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_FLOOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3023, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -79586,12 +67746,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_DX(CYTHON_UNUSED PyObject *_ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_DX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); - __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XDECREF((PyObject *)__pyx_v_real); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -79599,16 +67757,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_DX(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_531stream_EMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_547stream_HT_DCPERIOD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_530stream_EMA, " EMA(real[, timeperiod=?])\n\n Exponential Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_531stream_EMA = {"stream_EMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_531stream_EMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_530stream_EMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_531stream_EMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -79616,20 +67774,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_EMA (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_HT_DCPERIOD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -79637,89 +67794,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3178, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3025, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3025, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_EMA") < 0)) __PYX_ERR(4, 3025, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3178, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3027, __pyx_L3_error) - } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_EMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3025, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_HT_DCPERIOD", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3178, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_EMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3027, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_530stream_EMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3180, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_546stream_HT_DCPERIOD(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -79729,35 +67862,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_EMA(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_EMA", 0); + __Pyx_RefNannySetupContext("stream_HT_DCPERIOD", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3046, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3047, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3048, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_EMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_HT_DCPERIOD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_EMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3051, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_DCPERIOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3202, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3052, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -79767,7 +67896,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_EMA(CYTHON_UNUSED PyObject * /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_EMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -79778,16 +67907,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_EMA(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_533stream_EXP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_549stream_HT_DCPHASE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_532stream_EXP, " EXP(real)\n\n Vector Arithmetic Exp (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_533stream_EXP = {"stream_EXP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_533stream_EXP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_532stream_EXP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_533stream_EXP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -79805,9 +67934,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_EXP (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_HT_DCPHASE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -79815,71 +67944,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3205, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3054, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_EXP") < 0)) __PYX_ERR(4, 3054, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3205, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_EXP", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3054, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_HT_DCPHASE", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3205, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_EXP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3056, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_532stream_EXP(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3207, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_548stream_HT_DCPHASE(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -79889,35 +68012,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_EXP(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_EXP", 0); + __Pyx_RefNannySetupContext("stream_HT_DCPHASE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3073, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3074, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3075, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_EXP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_HT_DCPHASE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_EXP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3078, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_DCPHASE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3079, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -79927,7 +68046,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_EXP(CYTHON_UNUSED PyObject * /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_EXP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -79938,16 +68057,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_EXP(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_535stream_FLOOR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_551stream_HT_PHASOR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_534stream_FLOOR, " FLOOR(real)\n\n Vector Floor (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_535stream_FLOOR = {"stream_FLOOR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_535stream_FLOOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_534stream_FLOOR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_535stream_FLOOR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -79965,9 +68084,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_FLOOR (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_HT_PHASOR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -79975,119 +68094,126 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3232, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3081, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_FLOOR") < 0)) __PYX_ERR(4, 3081, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3232, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_FLOOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3081, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_HT_PHASOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3232, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3083, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_534stream_FLOOR(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3234, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_550stream_HT_PHASOR(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_534stream_FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outreal; + double __pyx_v_outinphase; + double __pyx_v_outquadrature; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_FLOOR", 0); + __Pyx_RefNannySetupContext("stream_HT_PHASOR", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3100, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3101, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3102, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outinphase = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_FLOOR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_outquadrature = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_retCode = TA_HT_PHASOR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinphase), (&__pyx_v_outquadrature)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_FLOOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3105, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_PHASOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3259, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3106, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outinphase); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outquadrature); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3260, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3260, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -80098,16 +68224,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_534stream_FLOOR(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_537stream_HT_DCPERIOD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_553stream_HT_SINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_536stream_HT_DCPERIOD, " HT_DCPERIOD(real)\n\n Hilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_537stream_HT_DCPERIOD = {"stream_HT_DCPERIOD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_537stream_HT_DCPERIOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_536stream_HT_DCPERIOD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_537stream_HT_DCPERIOD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -80125,9 +68251,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_HT_DCPERIOD (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_HT_SINE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -80135,119 +68261,126 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3262, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3108, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_HT_DCPERIOD") < 0)) __PYX_ERR(4, 3108, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3262, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_HT_DCPERIOD", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3108, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_HT_SINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3262, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3110, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_536stream_HT_DCPERIOD(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3264, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_552stream_HT_SINE(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outreal; + double __pyx_v_outsine; + double __pyx_v_outleadsine; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_HT_DCPERIOD", 0); + __Pyx_RefNannySetupContext("stream_HT_SINE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3127, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3283, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3128, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3129, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outsine = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_HT_DCPERIOD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_outleadsine = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_retCode = TA_HT_SINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outsine), (&__pyx_v_outleadsine)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_DCPERIOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3132, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_SINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3289, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3133, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outsine); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outleadsine); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3290, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3290, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -80258,16 +68391,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_HT_DCPERIOD(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_539stream_HT_DCPHASE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_555stream_HT_TRENDLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_538stream_HT_DCPHASE, " HT_DCPHASE(real)\n\n Hilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_539stream_HT_DCPHASE = {"stream_HT_DCPHASE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_539stream_HT_DCPHASE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_538stream_HT_DCPHASE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_539stream_HT_DCPHASE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -80285,9 +68418,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_HT_DCPHASE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_HT_TRENDLINE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -80295,71 +68428,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3292, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3135, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_HT_DCPHASE") < 0)) __PYX_ERR(4, 3135, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3292, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_HT_DCPHASE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3135, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDLINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3292, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3137, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3294, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_554stream_HT_TRENDLINE(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -80369,35 +68496,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(CYTHON_UNUSED PyO PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_HT_DCPHASE", 0); + __Pyx_RefNannySetupContext("stream_HT_TRENDLINE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3154, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3155, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3156, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_HT_DCPHASE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_HT_TRENDLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_DCPHASE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3159, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_TRENDLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3160, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -80407,7 +68530,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(CYTHON_UNUSED PyO /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -80418,16 +68541,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(CYTHON_UNUSED PyO /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_541stream_HT_PHASOR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_557stream_HT_TRENDMODE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_540stream_HT_PHASOR, " HT_PHASOR(real)\n\n Hilbert Transform - Phasor Components (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n inphase\n quadrature\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_541stream_HT_PHASOR = {"stream_HT_PHASOR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_541stream_HT_PHASOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_540stream_HT_PHASOR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_541stream_HT_PHASOR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -80445,9 +68568,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_HT_PHASOR (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_HT_TRENDMODE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -80455,136 +68578,109 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3319, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3162, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_HT_PHASOR") < 0)) __PYX_ERR(4, 3162, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3319, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_HT_PHASOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3162, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDMODE", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3319, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3164, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_540stream_HT_PHASOR(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3321, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_556stream_HT_TRENDMODE(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outinphase; - double __pyx_v_outquadrature; + int __pyx_v_outinteger; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_HT_PHASOR", 0); + __Pyx_RefNannySetupContext("stream_HT_TRENDMODE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3183, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3184, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3185, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outinphase = __pyx_v_5talib_7_ta_lib_NaN; - - __pyx_v_outquadrature = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outinteger = 0; - __pyx_v_retCode = TA_HT_PHASOR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinphase), (&__pyx_v_outquadrature)); + __pyx_v_retCode = TA_HT_TRENDMODE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_PHASOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3189, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_TRENDMODE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outinphase); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3190, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outquadrature); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3190, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 3190, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(4, 3190, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(4, 3190, __pyx_L1_error); + __pyx_r = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("talib._ta_lib.stream_HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -80595,36 +68691,38 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_HT_PHASOR(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_543stream_HT_SINE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_559stream_IMI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_542stream_HT_SINE, " HT_SINE(real)\n\n Hilbert Transform - SineWave (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n sine\n leadsine\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_543stream_HT_SINE = {"stream_HT_SINE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_543stream_HT_SINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_542stream_HT_SINE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_543stream_HT_SINE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_real = 0; + PyArrayObject *__pyx_v_open = 0; + PyArrayObject *__pyx_v_close = 0; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_HT_SINE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_IMI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -80632,139 +68730,148 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3346, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3346, __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(5, 3346, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3192, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + const Py_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) + 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) } } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_HT_SINE") < 0)) __PYX_ERR(4, 3192, __pyx_L3_error) + } else { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3346, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3346, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3346, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; + } + __pyx_v_open = ((PyArrayObject *)values[0]); + __pyx_v_close = ((PyArrayObject *)values[1]); + if (values[2]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3348, __pyx_L3_error) } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + __pyx_v_timeperiod = ((int)((int)-2147483648)); } - __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_HT_SINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3192, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_IMI", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 3346, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_IMI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3194, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_542stream_HT_SINE(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 3348, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 3348, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_558stream_IMI(__pyx_self, __pyx_v_open, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_IMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_real_data; + double *__pyx_v_open_data; + double *__pyx_v_close_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outsine; - double __pyx_v_outleadsine; + double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_HT_SINE", 0); - __Pyx_INCREF((PyObject *)__pyx_v_real); + __Pyx_RefNannySetupContext("stream_IMI", 0); + __Pyx_INCREF((PyObject *)__pyx_v_open); + __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3213, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3214, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3215, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; - __pyx_v_outsine = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_v_outleadsine = __pyx_v_5talib_7_ta_lib_NaN; + __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_retCode = TA_HT_SINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outsine), (&__pyx_v_outleadsine)); + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_retCode = TA_IMI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_SINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3219, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_IMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outsine); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3220, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outleadsine); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 3220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(4, 3220, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(4, 3220, __pyx_L1_error); + __pyx_r = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("talib._ta_lib.stream_HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_IMI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_real); + __Pyx_XDECREF((PyObject *)__pyx_v_open); + __Pyx_XDECREF((PyObject *)__pyx_v_close); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -80772,16 +68879,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_HT_SINE(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_545stream_HT_TRENDLINE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_561stream_KAMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_544stream_HT_TRENDLINE, " HT_TRENDLINE(real)\n\n Hilbert Transform - Instantaneous Trendline (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_545stream_HT_TRENDLINE = {"stream_HT_TRENDLINE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_545stream_HT_TRENDLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_544stream_HT_TRENDLINE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_545stream_HT_TRENDLINE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -80789,19 +68896,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_HT_TRENDLINE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_KAMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -80809,71 +68917,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3378, __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(5, 3378, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3222, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_HT_TRENDLINE") < 0)) __PYX_ERR(4, 3222, __pyx_L3_error) + const Py_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) + 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) } } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3378, __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(5, 3378, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } } __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3380, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDLINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3222, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_KAMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3378, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3224, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3380, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_560stream_KAMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -80883,35 +69001,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(CYTHON_UNUSED P PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_HT_TRENDLINE", 0); + __Pyx_RefNannySetupContext("stream_KAMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3241, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3242, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3243, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_HT_TRENDLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_KAMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_TRENDLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3246, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_KAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3247, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -80921,7 +69035,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(CYTHON_UNUSED P /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -80932,16 +69046,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_547stream_HT_TRENDMODE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_563stream_LINEARREG(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_546stream_HT_TRENDMODE, " HT_TRENDMODE(real)\n\n Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_547stream_HT_TRENDMODE = {"stream_HT_TRENDMODE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_547stream_HT_TRENDMODE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_546stream_HT_TRENDMODE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_547stream_HT_TRENDMODE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -80949,19 +69063,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_HT_TRENDMODE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_LINEARREG (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -80969,109 +69084,115 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3407, __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(5, 3407, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3249, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + const Py_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) + 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) } } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_HT_TRENDMODE") < 0)) __PYX_ERR(4, 3249, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3407, __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(5, 3407, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } } __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3409, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDMODE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3249, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_LINEARREG", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3407, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3251, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3409, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_562stream_LINEARREG(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - int __pyx_v_outinteger; + double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_HT_TRENDMODE", 0); + __Pyx_RefNannySetupContext("stream_LINEARREG", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3268, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3269, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3270, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outinteger = 0; + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_HT_TRENDMODE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_v_retCode = TA_LINEARREG((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_TRENDMODE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3273, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3274, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -81081,7 +69202,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(CYTHON_UNUSED P /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -81092,16 +69213,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(CYTHON_UNUSED P /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_549stream_KAMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_565stream_LINEARREG_ANGLE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_548stream_KAMA, " KAMA(real[, timeperiod=?])\n\n Kaufman Adaptive Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_549stream_KAMA = {"stream_KAMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_549stream_KAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_548stream_KAMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_549stream_KAMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -81120,9 +69241,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_KAMA (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_LINEARREG_ANGLE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -81130,89 +69251,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3436, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3436, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3276, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3276, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_KAMA") < 0)) __PYX_ERR(4, 3276, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3436, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3436, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3278, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3438, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_KAMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3276, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_ANGLE", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3436, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3278, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_548stream_KAMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3438, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_564stream_LINEARREG_ANGLE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -81222,35 +69335,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_KAMA(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_KAMA", 0); + __Pyx_RefNannySetupContext("stream_LINEARREG_ANGLE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3297, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3298, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3299, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_KAMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_LINEARREG_ANGLE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_KAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3302, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_ANGLE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3303, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3463, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -81260,7 +69369,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_KAMA(CYTHON_UNUSED PyObject /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -81271,16 +69380,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_KAMA(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_551stream_LINEARREG(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_550stream_LINEARREG, " LINEARREG(real[, timeperiod=?])\n\n Linear Regression (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_551stream_LINEARREG = {"stream_LINEARREG", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_551stream_LINEARREG, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_550stream_LINEARREG}; -static PyObject *__pyx_pw_5talib_7_ta_lib_551stream_LINEARREG(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -81299,9 +69408,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_LINEARREG (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_LINEARREG_INTERCEPT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -81309,89 +69418,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3465, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3465, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3305, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3305, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_LINEARREG") < 0)) __PYX_ERR(4, 3305, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3465, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3465, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3307, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3467, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_LINEARREG", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3305, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_INTERCEPT", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3465, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3307, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3467, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -81401,35 +69502,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(CYTHON_UNUSED PyOb PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_LINEARREG", 0); + __Pyx_RefNannySetupContext("stream_LINEARREG_INTERCEPT", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3326, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3486, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3327, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3328, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_LINEARREG((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_LINEARREG_INTERCEPT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3331, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_INTERCEPT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3491, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3332, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -81439,7 +69536,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(CYTHON_UNUSED PyOb /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -81450,16 +69547,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(CYTHON_UNUSED PyOb /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_553stream_LINEARREG_ANGLE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_569stream_LINEARREG_SLOPE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_552stream_LINEARREG_ANGLE, " LINEARREG_ANGLE(real[, timeperiod=?])\n\n Linear Regression Angle (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_553stream_LINEARREG_ANGLE = {"stream_LINEARREG_ANGLE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_553stream_LINEARREG_ANGLE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_552stream_LINEARREG_ANGLE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_553stream_LINEARREG_ANGLE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -81478,9 +69575,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_LINEARREG_ANGLE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_LINEARREG_SLOPE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -81488,89 +69585,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3494, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3494, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3334, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3334, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_LINEARREG_ANGLE") < 0)) __PYX_ERR(4, 3334, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3494, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3494, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3336, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3496, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_ANGLE", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3334, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_SLOPE", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3494, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3336, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3496, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_568stream_LINEARREG_SLOPE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -81580,35 +69669,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(CYTHON_UNUSE PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_LINEARREG_ANGLE", 0); + __Pyx_RefNannySetupContext("stream_LINEARREG_SLOPE", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3355, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3356, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3357, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_LINEARREG_ANGLE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_LINEARREG_SLOPE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_ANGLE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3360, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_SLOPE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3361, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -81618,7 +69703,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(CYTHON_UNUSE /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -81629,16 +69714,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(CYTHON_UNUSE /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_571stream_LN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT, " LINEARREG_INTERCEPT(real[, timeperiod=?])\n\n Linear Regression Intercept (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT = {"stream_LINEARREG_INTERCEPT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -81646,20 +69731,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_LINEARREG_INTERCEPT (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_LN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -81667,89 +69751,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3523, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3363, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3363, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_LINEARREG_INTERCEPT") < 0)) __PYX_ERR(4, 3363, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3523, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3365, __pyx_L3_error) - } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_INTERCEPT", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3363, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_LN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3523, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3365, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3525, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_570stream_LN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -81759,35 +69819,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(CYTHON_U PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_LINEARREG_INTERCEPT", 0); + __Pyx_RefNannySetupContext("stream_LN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3384, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3385, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3386, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_LINEARREG_INTERCEPT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_LN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_INTERCEPT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3389, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3390, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3548, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -81797,7 +69853,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(CYTHON_U /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LN", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -81808,16 +69864,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(CYTHON_U /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_557stream_LINEARREG_SLOPE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_573stream_LOG10(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_556stream_LINEARREG_SLOPE, " LINEARREG_SLOPE(real[, timeperiod=?])\n\n Linear Regression Slope (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_557stream_LINEARREG_SLOPE = {"stream_LINEARREG_SLOPE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_557stream_LINEARREG_SLOPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_556stream_LINEARREG_SLOPE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_557stream_LINEARREG_SLOPE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -81825,20 +69881,19 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_LINEARREG_SLOPE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_LOG10 (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -81846,89 +69901,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3550, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3392, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3392, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_LINEARREG_SLOPE") < 0)) __PYX_ERR(4, 3392, __pyx_L3_error) + const Py_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) + 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) } } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3550, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3394, __pyx_L3_error) - } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); - } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_SLOPE", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3392, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_LOG10", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3550, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3394, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3552, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_572stream_LOG10(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -81938,35 +69969,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(CYTHON_UNUSE PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_LINEARREG_SLOPE", 0); + __Pyx_RefNannySetupContext("stream_LOG10", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3413, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3414, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3415, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_LINEARREG_SLOPE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_LOG10((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_SLOPE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3418, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LOG10, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3419, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -81976,7 +70003,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(CYTHON_UNUSE /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -81987,16 +70014,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(CYTHON_UNUSE /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_559stream_LN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_575stream_MA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_558stream_LN, " LN(real)\n\n Vector Log Natural (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_559stream_LN = {"stream_LN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_559stream_LN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_558stream_LN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_559stream_LN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -82004,19 +70031,21 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; + int __pyx_v_timeperiod; + int __pyx_v_matype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_LN (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -82024,71 +70053,94 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3577, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3577, __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(5, 3577, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3421, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_LN") < 0)) __PYX_ERR(4, 3421, __pyx_L3_error) + const Py_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) + 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) } } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3577, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3577, __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(5, 3577, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } } __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3579, __pyx_L3_error) + } else { + __pyx_v_timeperiod = ((int)((int)-2147483648)); + } + if (values[2]) { + __pyx_v_matype = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3579, __pyx_L3_error) + } else { + __pyx_v_matype = ((int)((int)0)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_LN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3421, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MA", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 3577, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_LN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3423, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_558stream_LN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3579, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_574stream_MA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -82098,35 +70150,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_LN", 0); + __Pyx_RefNannySetupContext("stream_MA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3440, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3441, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3442, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_LN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_MA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3445, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3446, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -82136,7 +70184,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *_ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_LN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MA", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -82147,16 +70195,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_561stream_LOG10(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_577stream_MACD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_560stream_LOG10, " LOG10(real)\n\n Vector Log10 (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_561stream_LOG10 = {"stream_LOG10", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_561stream_LOG10, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_560stream_LOG10}; -static PyObject *__pyx_pw_5talib_7_ta_lib_561stream_LOG10(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -82164,19 +70212,22 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; + int __pyx_v_fastperiod; + int __pyx_v_slowperiod; + int __pyx_v_signalperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_LOG10 (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MACD (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -82184,119 +70235,178 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3607, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3607, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3607, __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(5, 3607, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3448, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + const Py_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) + 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) } } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_LOG10") < 0)) __PYX_ERR(4, 3448, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3607, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3607, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3607, __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(5, 3607, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } } __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3609, __pyx_L3_error) + } else { + __pyx_v_fastperiod = ((int)((int)-2147483648)); + } + if (values[2]) { + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3609, __pyx_L3_error) + } else { + __pyx_v_slowperiod = ((int)((int)-2147483648)); + } + if (values[3]) { + __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3609, __pyx_L3_error) + } else { + __pyx_v_signalperiod = ((int)((int)-2147483648)); + } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_LOG10", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3448, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MACD", 0, 1, 4, __pyx_nargs); __PYX_ERR(5, 3607, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MACD", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3450, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_560stream_LOG10(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3609, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_576stream_MACD(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outreal; + double __pyx_v_outmacd; + double __pyx_v_outmacdsignal; + double __pyx_v_outmacdhist; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_LOG10", 0); + __Pyx_RefNannySetupContext("stream_MACD", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3467, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3634, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3468, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3469, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_LOG10((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LOG10, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3472, __pyx_L1_error) + __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_retCode = TA_MACD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3473, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3642, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3642, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3642, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3642, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3642, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3642, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(5, 3642, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("talib._ta_lib.stream_MACD", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -82307,16 +70417,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_LOG10(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_563stream_MA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_579stream_MACDEXT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_562stream_MA, " MA(real[, timeperiod=?, matype=?])\n\n Moving average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n matype: 0 (Simple Moving Average)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_563stream_MA = {"stream_MA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_563stream_MA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_562stream_MA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_563stream_MA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -82324,21 +70434,25 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - int __pyx_v_timeperiod; - int __pyx_v_matype; + int __pyx_v_fastperiod; + int __pyx_v_fastmatype; + int __pyx_v_slowperiod; + int __pyx_v_slowmatype; + int __pyx_v_signalperiod; + int __pyx_v_signalmatype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; + PyObject* values[7] = {0,0,0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MA (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MACDEXT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -82346,153 +70460,217 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 3644, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 3644, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3644, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3475, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3644, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3475, __pyx_L3_error) - } + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3644, __pyx_L3_error) CYTHON_FALLTHROUGH; case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3475, __pyx_L3_error) - } + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3644, __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(5, 3644, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MA") < 0)) __PYX_ERR(4, 3475, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 3644, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 3644, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3644, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3644, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3644, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3644, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3644, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3477, __pyx_L3_error) + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error) } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); + __pyx_v_fastperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3477, __pyx_L3_error) + __pyx_v_fastmatype = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_fastmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error) } else { - __pyx_v_matype = ((int)((int)0)); + __pyx_v_fastmatype = ((int)((int)0)); + } + if (values[3]) { + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error) + } else { + __pyx_v_slowperiod = ((int)((int)-2147483648)); + } + if (values[4]) { + __pyx_v_slowmatype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_slowmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error) + } else { + __pyx_v_slowmatype = ((int)((int)0)); + } + if (values[5]) { + __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error) + } else { + __pyx_v_signalperiod = ((int)((int)-2147483648)); + } + if (values[6]) { + __pyx_v_signalmatype = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_signalmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error) + } else { + __pyx_v_signalmatype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MA", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 3475, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MACDEXT", 0, 1, 7, __pyx_nargs); __PYX_ERR(5, 3644, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3477, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_562stream_MA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3646, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_578stream_MACDEXT(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outreal; + double __pyx_v_outmacd; + double __pyx_v_outmacdsignal; + double __pyx_v_outmacdhist; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MA", 0); + __Pyx_RefNannySetupContext("stream_MACDEXT", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3497, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3498, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3499, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_MA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3502, __pyx_L1_error) + __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_retCode = TA_MACDEXT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACDEXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3503, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3682, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3682, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3682, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(5, 3682, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("talib._ta_lib.stream_MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -82503,16 +70681,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_MA(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_565stream_MACD(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_581stream_MACDFIX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_564stream_MACD, " MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\n Moving Average Convergence/Divergence (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastperiod: 12\n slowperiod: 26\n signalperiod: 9\n Outputs:\n macd\n macdsignal\n macdhist\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_565stream_MACD = {"stream_MACD", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_565stream_MACD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_564stream_MACD}; -static PyObject *__pyx_pw_5talib_7_ta_lib_565stream_MACD(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -82520,22 +70698,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - int __pyx_v_fastperiod; - int __pyx_v_slowperiod; int __pyx_v_signalperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {0,0,0,0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MACD (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MACDFIX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -82543,121 +70719,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_signalperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3684, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3684, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3505, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3505, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3505, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_signalperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3505, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MACD") < 0)) __PYX_ERR(4, 3505, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3684, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3684, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3507, __pyx_L3_error) - } else { - __pyx_v_fastperiod = ((int)((int)-2147483648)); - } - if (values[2]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3507, __pyx_L3_error) - } else { - __pyx_v_slowperiod = ((int)((int)-2147483648)); - } - if (values[3]) { - __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3507, __pyx_L3_error) + __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3686, __pyx_L3_error) } else { __pyx_v_signalperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MACD", 0, 1, 4, __pyx_nargs); __PYX_ERR(4, 3505, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MACDFIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3684, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MACD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3507, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_564stream_MACD(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3686, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_580stream_MACDFIX(__pyx_self, __pyx_v_real, __pyx_v_signalperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -82669,27 +70805,23 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_MACD(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MACD", 0); + __Pyx_RefNannySetupContext("stream_MACDFIX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3532, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3709, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3533, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3534, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN; @@ -82697,42 +70829,42 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_MACD(CYTHON_UNUSED PyObject __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_MACD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist)); + __pyx_v_retCode = TA_MACDFIX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3539, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACDFIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3716, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3540, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3717, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3540, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3717, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 3540, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3540, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1)) __PYX_ERR(4, 3540, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(4, 3540, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(4, 3540, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3717, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3717, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(5, 3717, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __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.stream_MACD", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -82743,16 +70875,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_MACD(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_567stream_MACDEXT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_583stream_MAMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_566stream_MACDEXT, " MACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\n MACD with controllable MA type (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastperiod: 12\n fastmatype: 0\n slowperiod: 26\n slowmatype: 0\n signalperiod: 9\n signalmatype: 0\n Outputs:\n macd\n macdsignal\n macdhist\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_567stream_MACDEXT = {"stream_MACDEXT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_567stream_MACDEXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_566stream_MACDEXT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_567stream_MACDEXT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -82760,25 +70892,21 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - int __pyx_v_fastperiod; - int __pyx_v_fastmatype; - int __pyx_v_slowperiod; - int __pyx_v_slowmatype; - int __pyx_v_signalperiod; - int __pyx_v_signalmatype; + double __pyx_v_fastlimit; + double __pyx_v_slowlimit; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[7] = {0,0,0,0,0,0,0}; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MACDEXT (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MAMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -82786,244 +70914,155 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_fastmatype,&__pyx_n_s_slowperiod,&__pyx_n_s_slowmatype,&__pyx_n_s_signalperiod,&__pyx_n_s_signalmatype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); - CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); - CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3719, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3719, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3719, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3542, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3542, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastmatype); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3542, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3542, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowmatype); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3542, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_signalperiod); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3542, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 6: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_signalmatype); - if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3542, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MACDEXT") < 0)) __PYX_ERR(4, 3542, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); - CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); - CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3719, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3719, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3719, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3544, __pyx_L3_error) + __pyx_v_fastlimit = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_fastlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 3721, __pyx_L3_error) } else { - __pyx_v_fastperiod = ((int)((int)-2147483648)); + __pyx_v_fastlimit = ((double)((double)-4e37)); } if (values[2]) { - __pyx_v_fastmatype = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_fastmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3544, __pyx_L3_error) - } else { - __pyx_v_fastmatype = ((int)((int)0)); - } - if (values[3]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3544, __pyx_L3_error) - } else { - __pyx_v_slowperiod = ((int)((int)-2147483648)); - } - if (values[4]) { - __pyx_v_slowmatype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_slowmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3544, __pyx_L3_error) - } else { - __pyx_v_slowmatype = ((int)((int)0)); - } - if (values[5]) { - __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3544, __pyx_L3_error) - } else { - __pyx_v_signalperiod = ((int)((int)-2147483648)); - } - if (values[6]) { - __pyx_v_signalmatype = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_signalmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3544, __pyx_L3_error) + __pyx_v_slowlimit = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_slowlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 3721, __pyx_L3_error) } else { - __pyx_v_signalmatype = ((int)((int)0)); + __pyx_v_slowlimit = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MACDEXT", 0, 1, 7, __pyx_nargs); __PYX_ERR(4, 3542, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MAMA", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 3719, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3544, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_566stream_MACDEXT(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3721, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_582stream_MAMA(__pyx_self, __pyx_v_real, __pyx_v_fastlimit, __pyx_v_slowlimit); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outmacd; - double __pyx_v_outmacdsignal; - double __pyx_v_outmacdhist; + double __pyx_v_outmama; + double __pyx_v_outfama; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MACDEXT", 0); + __Pyx_RefNannySetupContext("stream_MAMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3572, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3573, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); - - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3574, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outmama = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outfama = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_MACDEXT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist)); + __pyx_v_retCode = TA_MAMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastlimit, __pyx_v_slowlimit, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmama), (&__pyx_v_outfama)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACDEXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3579, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3580, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmama); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3750, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3580, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 3580, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3580, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outfama); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1)) __PYX_ERR(4, 3580, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(4, 3580, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(4, 3580, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3750, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3750, __pyx_L1_error); __pyx_t_1 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("talib._ta_lib.stream_MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("talib._ta_lib.stream_MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -83034,16 +71073,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_MACDEXT(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_569stream_MACDFIX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_585stream_MAVP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_568stream_MACDFIX, " MACDFIX(real[, signalperiod=?])\n\n Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n signalperiod: 9\n Outputs:\n macd\n macdsignal\n macdhist\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_569stream_MACDFIX = {"stream_MACDFIX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_569stream_MACDFIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_568stream_MACDFIX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_569stream_MACDFIX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -83051,20 +71090,23 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - int __pyx_v_signalperiod; + PyArrayObject *__pyx_v_periods = 0; + int __pyx_v_minperiod; + int __pyx_v_maxperiod; + int __pyx_v_matype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MACDFIX (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MAVP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -83072,167 +71114,174 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_signalperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3752, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3752, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3582, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3752, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3752, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_signalperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3582, __pyx_L3_error) - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3752, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MACDFIX") < 0)) __PYX_ERR(4, 3582, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3752, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3752, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3752, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3752, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3752, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3584, __pyx_L3_error) + __pyx_v_periods = ((PyArrayObject *)values[1]); + if (values[2]) { + __pyx_v_minperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_minperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3754, __pyx_L3_error) } else { - __pyx_v_signalperiod = ((int)((int)-2147483648)); + __pyx_v_minperiod = ((int)((int)-2147483648)); + } + if (values[3]) { + __pyx_v_maxperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_maxperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3754, __pyx_L3_error) + } else { + __pyx_v_maxperiod = ((int)((int)-2147483648)); + } + if (values[4]) { + __pyx_v_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3754, __pyx_L3_error) + } else { + __pyx_v_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MACDFIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3582, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MAVP", 0, 2, 5, __pyx_nargs); __PYX_ERR(5, 3752, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3584, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_568stream_MACDFIX(__pyx_self, __pyx_v_real, __pyx_v_signalperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3754, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_periods), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "periods", 0))) __PYX_ERR(5, 3754, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_584stream_MAVP(__pyx_self, __pyx_v_real, __pyx_v_periods, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; + double *__pyx_v_periods_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outmacd; - double __pyx_v_outmacdsignal; - double __pyx_v_outmacdhist; + double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MACDFIX", 0); + __Pyx_RefNannySetupContext("stream_MAVP", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); + __Pyx_INCREF((PyObject *)__pyx_v_periods); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3607, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3777, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3608, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3609, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_periods)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_periods, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; - __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_periods_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods)); - __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN; + __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_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_MACDFIX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist)); + __pyx_v_retCode = TA_MAVP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_periods_data, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACDFIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3614, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAVP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3615, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3615, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 3615, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3615, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1)) __PYX_ERR(4, 3615, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(4, 3615, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(4, 3615, __pyx_L1_error); + __pyx_r = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("talib._ta_lib.stream_MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); + __Pyx_XDECREF((PyObject *)__pyx_v_periods); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -83240,16 +71289,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_MACDFIX(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_571stream_MAMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_587stream_MAX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_570stream_MAMA, " MAMA(real[, fastlimit=?, slowlimit=?])\n\n MESA Adaptive Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastlimit: 0.5\n slowlimit: 0.05\n Outputs:\n mama\n fama\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_571stream_MAMA = {"stream_MAMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_571stream_MAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_570stream_MAMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_571stream_MAMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -83257,21 +71306,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - double __pyx_v_fastlimit; - double __pyx_v_slowlimit; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MAMA (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MAX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -83279,170 +71327,125 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastlimit,&__pyx_n_s_slowlimit,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3787, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3617, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastlimit); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3617, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowlimit); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3617, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MAMA") < 0)) __PYX_ERR(4, 3617, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3787, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3787, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastlimit = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_fastlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 3619, __pyx_L3_error) - } else { - __pyx_v_fastlimit = ((double)((double)-4e37)); - } - if (values[2]) { - __pyx_v_slowlimit = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_slowlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 3619, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3789, __pyx_L3_error) } else { - __pyx_v_slowlimit = ((double)((double)-4e37)); + __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MAMA", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 3617, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3787, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MAX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3619, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_570stream_MAMA(__pyx_self, __pyx_v_real, __pyx_v_fastlimit, __pyx_v_slowlimit); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3789, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_586stream_MAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit) { +static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outmama; - double __pyx_v_outfama; + double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MAMA", 0); + __Pyx_RefNannySetupContext("stream_MAX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3641, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3808, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3642, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3643, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outmama = __pyx_v_5talib_7_ta_lib_NaN; - - __pyx_v_outfama = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_MAMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastlimit, __pyx_v_slowlimit, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmama), (&__pyx_v_outfama)); + __pyx_v_retCode = TA_MAX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3647, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmama); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3648, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outfama); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3648, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 3648, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(4, 3648, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(4, 3648, __pyx_L1_error); + __pyx_r = __pyx_t_1; __pyx_t_1 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("talib._ta_lib.stream_MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MAX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -83453,16 +71456,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_MAMA(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_573stream_MAVP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_589stream_MAXINDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_572stream_MAVP, " MAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\n Moving average with variable period (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n periods: (any ndarray)\n Parameters:\n minperiod: 2\n maxperiod: 30\n matype: 0 (Simple Moving Average)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_573stream_MAVP = {"stream_MAVP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_573stream_MAVP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_572stream_MAVP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_573stream_MAVP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -83470,23 +71473,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; - PyArrayObject *__pyx_v_periods = 0; - int __pyx_v_minperiod; - int __pyx_v_maxperiod; - int __pyx_v_matype; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MAVP (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MAXINDEX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -83494,184 +71494,115 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_periods,&__pyx_n_s_minperiod,&__pyx_n_s_maxperiod,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3816, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3816, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3650, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_periods)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3650, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MAVP", 0, 2, 5, 1); __PYX_ERR(4, 3650, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_minperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3650, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3650, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3650, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MAVP") < 0)) __PYX_ERR(4, 3650, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3816, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3816, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); - __pyx_v_periods = ((PyArrayObject *)values[1]); - if (values[2]) { - __pyx_v_minperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_minperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3652, __pyx_L3_error) - } else { - __pyx_v_minperiod = ((int)((int)-2147483648)); - } - if (values[3]) { - __pyx_v_maxperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_maxperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3652, __pyx_L3_error) - } else { - __pyx_v_maxperiod = ((int)((int)-2147483648)); - } - if (values[4]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3652, __pyx_L3_error) + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3818, __pyx_L3_error) } else { - __pyx_v_matype = ((int)((int)0)); + __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MAVP", 0, 2, 5, __pyx_nargs); __PYX_ERR(4, 3650, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3816, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3652, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_periods), __pyx_ptype_5numpy_ndarray, 0, "periods", 0))) __PYX_ERR(4, 3652, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_572stream_MAVP(__pyx_self, __pyx_v_real, __pyx_v_periods, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3818, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_588stream_MAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; - double *__pyx_v_periods_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outreal; + int __pyx_v_outinteger; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MAVP", 0); + __Pyx_RefNannySetupContext("stream_MAXINDEX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __Pyx_INCREF((PyObject *)__pyx_v_periods); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3675, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3837, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3676, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_periods)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3677, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_periods, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3678, __pyx_L1_error) - __pyx_v_periods_data = ((double *)__pyx_t_2); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 3679, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; - - __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outinteger = 0; - __pyx_v_retCode = TA_MAVP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_periods_data, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_MAXINDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAVP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3682, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3842, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3683, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -83681,11 +71612,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_MAVP(CYTHON_UNUSED PyObject /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); - __Pyx_XDECREF((PyObject *)__pyx_v_periods); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -83693,24 +71623,24 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_MAVP(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_575stream_MAX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_591stream_MEDPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_574stream_MAX, " MAX(real[, timeperiod=?])\n\n Highest value over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_575stream_MAX = {"stream_MAX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_575stream_MAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_574stream_MAX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_575stream_MAX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_real = 0; - int __pyx_v_timeperiod; + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif @@ -83721,9 +71651,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MAX (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MEDPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -83731,127 +71661,118 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3845, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3845, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3685, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3685, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MAX") < 0)) __PYX_ERR(4, 3685, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 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, "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) } } - } - __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3687, __pyx_L3_error) + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3845, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3845, __pyx_L3_error) } + __pyx_v_high = ((PyArrayObject *)values[0]); + __pyx_v_low = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3685, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MEDPRICE", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 3845, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MAX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3687, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_574stream_MAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 3847, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 3847, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_590stream_MEDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_real_data; + double *__pyx_v_high_data; + double *__pyx_v_low_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MAX", 0); - __Pyx_INCREF((PyObject *)__pyx_v_real); + __Pyx_RefNannySetupContext("stream_MEDPRICE", 0); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3706, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3865, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3707, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3708, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[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)-1L))) __PYX_ERR(5, 3869, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_MAX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_MEDPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3711, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MEDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3872, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3712, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -83861,10 +71782,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MAX(CYTHON_UNUSED PyObject * /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MAX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_real); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -83872,37 +71794,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MAX(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_577stream_MAXINDEX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_593stream_MFI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_576stream_MAXINDEX, " MAXINDEX(real[, timeperiod=?])\n\n Index of highest value over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_577stream_MAXINDEX = {"stream_MAXINDEX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_577stream_MAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_576stream_MAXINDEX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_577stream_MAXINDEX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_real = 0; + PyArrayObject *__pyx_v_high = 0; + PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_close = 0; + PyArrayObject *__pyx_v_volume = 0; int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MAXINDEX (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MFI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -83910,127 +71835,168 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3875, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3875, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3714, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3875, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3875, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3714, __pyx_L3_error) - } + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3875, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MAXINDEX") < 0)) __PYX_ERR(4, 3714, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3875, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3875, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3875, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3875, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3875, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } - __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3716, __pyx_L3_error) + __pyx_v_high = ((PyArrayObject *)values[0]); + __pyx_v_low = ((PyArrayObject *)values[1]); + __pyx_v_close = ((PyArrayObject *)values[2]); + __pyx_v_volume = ((PyArrayObject *)values[3]); + if (values[4]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3877, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3714, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 3875, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MFI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3716, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 3877, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 3877, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 3877, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(5, 3877, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_592stream_MFI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_real_data; + double *__pyx_v_high_data; + double *__pyx_v_low_data; + double *__pyx_v_close_data; + double *__pyx_v_volume_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - int __pyx_v_outinteger; + double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MAXINDEX", 0); - __Pyx_INCREF((PyObject *)__pyx_v_real); + __Pyx_RefNannySetupContext("stream_MFI", 0); + __Pyx_INCREF((PyObject *)__pyx_v_high); + __Pyx_INCREF((PyObject *)__pyx_v_low); + __Pyx_INCREF((PyObject *)__pyx_v_close); + __Pyx_INCREF((PyObject *)__pyx_v_volume); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3735, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3736, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3737, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; - __pyx_v_outinteger = 0; + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_v_retCode = TA_MAXINDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3903, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3740, __pyx_L1_error) + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); + + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3905, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + __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)-1L))) __PYX_ERR(5, 3907, __pyx_L1_error) + __pyx_v_length = __pyx_t_2; + + __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + + __pyx_v_retCode = TA_MFI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MFI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3910, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3741, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3911, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -84040,10 +72006,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(CYTHON_UNUSED PyObj /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MFI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_real); + __Pyx_XDECREF((PyObject *)__pyx_v_high); + __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_close); + __Pyx_XDECREF((PyObject *)__pyx_v_volume); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -84051,24 +72020,24 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_579stream_MEDPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_595stream_MIDPOINT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_578stream_MEDPRICE, " MEDPRICE(high, low)\n\n Median Price (Price Transform)\n\n Inputs:\n prices: ['high', 'low']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_579stream_MEDPRICE = {"stream_MEDPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_579stream_MEDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_578stream_MEDPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_579stream_MEDPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_real = 0; + int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif @@ -84079,9 +72048,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MEDPRICE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MIDPOINT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -84089,134 +72058,115 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3913, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3913, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + const Py_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) + 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) } + } + } else { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3743, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3913, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3743, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MEDPRICE", 1, 2, 2, 1); __PYX_ERR(4, 3743, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MEDPRICE") < 0)) __PYX_ERR(4, 3743, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3913, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; + } + __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3915, __pyx_L3_error) } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + __pyx_v_timeperiod = ((int)((int)-2147483648)); } - __pyx_v_high = ((PyArrayObject *)values[0]); - __pyx_v_low = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MEDPRICE", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 3743, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MIDPOINT", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3913, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3745, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3745, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3915, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_594stream_MIDPOINT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low) { +static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_high_data; - double *__pyx_v_low_data; + double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MEDPRICE", 0); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3763, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3764, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __Pyx_RefNannySetupContext("stream_MIDPOINT", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3765, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3934, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3766, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 3767, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_MEDPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_MIDPOINT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MEDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3770, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIDPOINT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3939, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3771, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -84226,11 +72176,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(CYTHON_UNUSED PyObj /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_real); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -84238,16 +72187,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_581stream_MFI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_597stream_MIDPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_580stream_MFI, " MFI(high, low, close, volume[, timeperiod=?])\n\n Money Flow Index (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close', 'volume']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_581stream_MFI = {"stream_MFI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_581stream_MFI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_580stream_MFI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_581stream_MFI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -84256,22 +72205,20 @@ PyObject *__pyx_args, PyObject *__pyx_kwds ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; - PyArrayObject *__pyx_v_close = 0; - PyArrayObject *__pyx_v_volume = 0; int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MFI (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MIDPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -84279,202 +72226,134 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3942, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3942, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3942, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3773, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3773, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, 1); __PYX_ERR(4, 3773, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3773, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, 2); __PYX_ERR(4, 3773, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_volume)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3773, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, 3); __PYX_ERR(4, 3773, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3773, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MFI") < 0)) __PYX_ERR(4, 3773, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3942, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3942, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3942, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); - __pyx_v_close = ((PyArrayObject *)values[2]); - __pyx_v_volume = ((PyArrayObject *)values[3]); - if (values[4]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3775, __pyx_L3_error) + if (values[2]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3944, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 3773, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MIDPRICE", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 3942, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MFI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3775, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3775, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 3775, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 3775, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_580stream_MFI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 3944, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 3944, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_596stream_MIDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; double *__pyx_v_low_data; - double *__pyx_v_close_data; - double *__pyx_v_volume_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outreal; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MFI", 0); + __Pyx_RefNannySetupContext("stream_MIDPRICE", 0); __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __Pyx_INCREF((PyObject *)__pyx_v_close); - __Pyx_INCREF((PyObject *)__pyx_v_volume); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3797, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3964, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3798, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3799, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3966, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3800, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3801, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3802, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3803, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3804, __pyx_L1_error) - __pyx_v_volume_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 3805, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; - __pyx_v_retCode = TA_MFI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_MIDPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MFI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3808, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3809, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3972, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -84484,13 +72363,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MFI(CYTHON_UNUSED PyObject * /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MFI", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); - __Pyx_XDECREF((PyObject *)__pyx_v_close); - __Pyx_XDECREF((PyObject *)__pyx_v_volume); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -84498,16 +72375,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MFI(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_583stream_MIDPOINT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_599stream_MIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_582stream_MIDPOINT, " MIDPOINT(real[, timeperiod=?])\n\n MidPoint over period (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_583stream_MIDPOINT = {"stream_MIDPOINT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_583stream_MIDPOINT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_582stream_MIDPOINT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_583stream_MIDPOINT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -84526,9 +72403,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MIDPOINT (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MIN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -84536,89 +72413,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3974, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3974, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3811, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3811, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MIDPOINT") < 0)) __PYX_ERR(4, 3811, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3974, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3974, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3813, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3976, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MIDPOINT", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3811, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MIN", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3974, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MIN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3813, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3976, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_598stream_MIN(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -84628,35 +72497,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MIDPOINT", 0); + __Pyx_RefNannySetupContext("stream_MIN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3832, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3995, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3833, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3834, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_MIDPOINT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_MIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIDPOINT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3837, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3838, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -84666,7 +72531,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObj /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MIN", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -84677,38 +72542,37 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_585stream_MIDPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_601stream_MININDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_584stream_MIDPRICE, " MIDPRICE(high, low[, timeperiod=?])\n\n Midpoint Price over period (Overlap Studies)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_585stream_MIDPRICE = {"stream_MIDPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_585stream_MIDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_584stream_MIDPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_585stream_MIDPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyArrayObject *__pyx_v_high = 0; - PyArrayObject *__pyx_v_low = 0; + PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MIDPRICE (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MININDEX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -84716,152 +72580,115 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4003, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4003, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3840, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3840, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MIDPRICE", 0, 2, 3, 1); __PYX_ERR(4, 3840, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3840, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MIDPRICE") < 0)) __PYX_ERR(4, 3840, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4003, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4003, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } - __pyx_v_high = ((PyArrayObject *)values[0]); - __pyx_v_low = ((PyArrayObject *)values[1]); - if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3842, __pyx_L3_error) + __pyx_v_real = ((PyArrayObject *)values[0]); + if (values[1]) { + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4005, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MIDPRICE", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 3840, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MININDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4003, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3842, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3842, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_584stream_MIDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4005, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_600stream_MININDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; - double *__pyx_v_high_data; - double *__pyx_v_low_data; + double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outreal; + int __pyx_v_outinteger; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MIDPRICE", 0); - __Pyx_INCREF((PyObject *)__pyx_v_high); - __Pyx_INCREF((PyObject *)__pyx_v_low); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3862, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3863, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __Pyx_RefNannySetupContext("stream_MININDEX", 0); + __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3864, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4024, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); + __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3865, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 3866, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outinteger = 0; - __pyx_v_retCode = TA_MIDPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_retCode = TA_MININDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3869, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MININDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4029, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3870, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4030, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -84871,11 +72698,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MIDPRICE(CYTHON_UNUSED PyObj /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_high); - __Pyx_XDECREF((PyObject *)__pyx_v_low); + __Pyx_XDECREF((PyObject *)__pyx_v_real); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -84883,16 +72709,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MIDPRICE(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_587stream_MIN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_603stream_MINMAX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_586stream_MIN, " MIN(real[, timeperiod=?])\n\n Lowest value over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_587stream_MIN = {"stream_MIN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_587stream_MIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_586stream_MIN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_587stream_MIN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -84911,9 +72737,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MIN (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MINMAX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -84921,137 +72747,142 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4032, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4032, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3872, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3872, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MIN") < 0)) __PYX_ERR(4, 3872, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4032, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4032, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3874, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4034, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MIN", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3872, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MINMAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4032, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } - __Pyx_AddTraceback("talib._ta_lib.stream_MIN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("talib._ta_lib.stream_MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3874, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_586stream_MIN(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4034, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_602stream_MINMAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; - double __pyx_v_outreal; + double __pyx_v_outmin; + double __pyx_v_outmax; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MIN", 0); + __Pyx_RefNannySetupContext("stream_MINMAX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3893, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4055, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3894, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3895, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); - __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; + __pyx_v_outmin = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_v_retCode = TA_MIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); + __pyx_v_outmax = __pyx_v_5talib_7_ta_lib_NaN; - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3898, __pyx_L1_error) + __pyx_v_retCode = TA_MINMAX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmin), (&__pyx_v_outmax)); + + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINMAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3899, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmin); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4062, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmax); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4062, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 4062, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MIN", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("talib._ta_lib.stream_MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); @@ -85062,16 +72893,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MIN(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_589stream_MININDEX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_605stream_MINMAXINDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_588stream_MININDEX, " MININDEX(real[, timeperiod=?])\n\n Index of lowest value over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n integer (values are -100, 0 or 100)\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_589stream_MININDEX = {"stream_MININDEX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_589stream_MININDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_588stream_MININDEX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_589stream_MININDEX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -85090,9 +72921,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MININDEX (wrapper)", 0); + __Pyx_RefNannySetupContext("stream_MINMAXINDEX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -85100,464 +72931,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3901, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4064, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3901, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MININDEX") < 0)) __PYX_ERR(4, 3901, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3903, __pyx_L3_error) - } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MININDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3901, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("talib._ta_lib.stream_MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3903, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_588stream_MININDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { - npy_intp __pyx_v_length; - TA_RetCode __pyx_v_retCode; - double *__pyx_v_real_data; - int __pyx_v_outbegidx; - int __pyx_v_outnbelement; - int __pyx_v_outinteger; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MININDEX", 0); - __Pyx_INCREF((PyObject *)__pyx_v_real); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3922, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3923, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); - - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3924, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); - - __pyx_v_outinteger = 0; - - __pyx_v_retCode = TA_MININDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger)); - - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MININDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3927, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3928, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("talib._ta_lib.stream_MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_real); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - - -/* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_591stream_MINMAX(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_590stream_MINMAX, " MINMAX(real[, timeperiod=?])\n\n Lowest and highest values over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n min\n max\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_591stream_MINMAX = {"stream_MINMAX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_591stream_MINMAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_590stream_MINMAX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_591stream_MINMAX(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyArrayObject *__pyx_v_real = 0; - int __pyx_v_timeperiod; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MINMAX (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4064, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3930, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3930, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MINMAX") < 0)) __PYX_ERR(4, 3930, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 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, "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) } } - } - __pyx_v_real = ((PyArrayObject *)values[0]); - if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3932, __pyx_L3_error) } else { - __pyx_v_timeperiod = ((int)((int)-2147483648)); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MINMAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3930, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("talib._ta_lib.stream_MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3932, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_590stream_MINMAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { - npy_intp __pyx_v_length; - TA_RetCode __pyx_v_retCode; - double *__pyx_v_real_data; - int __pyx_v_outbegidx; - int __pyx_v_outnbelement; - double __pyx_v_outmin; - double __pyx_v_outmax; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("stream_MINMAX", 0); - __Pyx_INCREF((PyObject *)__pyx_v_real); - - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3953, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3954, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); - - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3955, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); - - __pyx_v_outmin = __pyx_v_5talib_7_ta_lib_NaN; - - __pyx_v_outmax = __pyx_v_5talib_7_ta_lib_NaN; - - __pyx_v_retCode = TA_MINMAX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmin), (&__pyx_v_outmax)); - - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINMAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3959, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmin); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3960, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outmax); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3960, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 3960, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(4, 3960, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(4, 3960, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("talib._ta_lib.stream_MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_real); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - - -/* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_593stream_MINMAXINDEX(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_592stream_MINMAXINDEX, " MINMAXINDEX(real[, timeperiod=?])\n\n Indexes of lowest and highest values over a specified period (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n minidx\n maxidx\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_593stream_MINMAXINDEX = {"stream_MINMAXINDEX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_593stream_MINMAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_592stream_MINMAXINDEX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_593stream_MINMAXINDEX(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyArrayObject *__pyx_v_real = 0; - int __pyx_v_timeperiod; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("stream_MINMAXINDEX (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3962, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4064, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3962, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MINMAXINDEX") < 0)) __PYX_ERR(4, 3962, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4064, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3964, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4066, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MINMAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3962, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MINMAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4064, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3964, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4066, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_604stream_MINMAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -85568,26 +73016,22 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(CYTHON_UNUSED Py PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_MINMAXINDEX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3985, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4087, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3986, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 3987, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outminidx = 0; @@ -85595,33 +73039,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(CYTHON_UNUSED Py __pyx_v_retCode = TA_MINMAXINDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outminidx), (&__pyx_v_outmaxidx)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINMAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3991, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINMAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4093, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outminidx); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3992, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outminidx); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4094, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_outmaxidx); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3992, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 3992, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_outmaxidx); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(4, 3992, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(4, 3992, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4094, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 4094, __pyx_L1_error); __pyx_t_1 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("talib._ta_lib.stream_MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -85633,16 +73077,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(CYTHON_UNUSED Py /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_595stream_MINUS_DI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_607stream_MINUS_DI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_594stream_MINUS_DI, " MINUS_DI(high, low, close[, timeperiod=?])\n\n Minus Directional Indicator (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_595stream_MINUS_DI = {"stream_MINUS_DI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_595stream_MINUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_594stream_MINUS_DI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_595stream_MINUS_DI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -85665,7 +73109,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_MINUS_DI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -85673,69 +73117,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4096, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4096, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4096, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4096, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3994, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3994, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, 1); __PYX_ERR(4, 3994, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3994, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, 2); __PYX_ERR(4, 3994, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 3994, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MINUS_DI") < 0)) __PYX_ERR(4, 3994, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4096, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4096, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4096, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4096, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -85744,48 +73167,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3996, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4098, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 3994, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 4096, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3996, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3996, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 3996, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4098, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4098, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4098, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_606stream_MINUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -85797,8 +73219,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -85807,43 +73228,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4017, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4018, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4019, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4020, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4021, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4022, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4023, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_MINUS_DI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4026, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4027, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -85866,16 +73284,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_597stream_MINUS_DM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_609stream_MINUS_DM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_596stream_MINUS_DM, " MINUS_DM(high, low[, timeperiod=?])\n\n Minus Directional Movement (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_597stream_MINUS_DM = {"stream_MINUS_DM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_597stream_MINUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_596stream_MINUS_DM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_597stream_MINUS_DM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -85897,7 +73315,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_MINUS_DM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -85905,56 +73323,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4131, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4131, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4131, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4029, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4029, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MINUS_DM", 0, 2, 3, 1); __PYX_ERR(4, 4029, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4029, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MINUS_DM") < 0)) __PYX_ERR(4, 4029, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4131, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4131, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4131, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -85962,47 +73366,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4031, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4133, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MINUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 4029, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MINUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 4131, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4031, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4031, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4133, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4133, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_608stream_MINUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -86013,8 +73416,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -86022,35 +73424,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4051, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4153, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4052, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4053, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4054, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4055, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_MINUS_DM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4058, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4059, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -86072,16 +73472,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_599stream_MOM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_611stream_MOM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_598stream_MOM, " MOM(real[, timeperiod=?])\n\n Momentum (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_599stream_MOM = {"stream_MOM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_599stream_MOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_598stream_MOM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_599stream_MOM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -86102,7 +73502,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_MOM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -86110,89 +73510,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4163, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4163, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4061, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4061, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MOM") < 0)) __PYX_ERR(4, 4061, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4163, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4163, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4063, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4165, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MOM", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4061, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MOM", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4163, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_MOM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4063, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_598stream_MOM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4165, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_610stream_MOM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -86202,35 +73594,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MOM(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_MOM", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4082, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4083, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4084, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_MOM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4087, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4088, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -86251,16 +73639,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MOM(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_601stream_MULT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_613stream_MULT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_600stream_MULT, " MULT(real0, real1)\n\n Vector Arithmetic Mult (Math Operators)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_601stream_MULT = {"stream_MULT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_601stream_MULT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_600stream_MULT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_601stream_MULT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -86281,7 +73669,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_MULT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -86289,86 +73677,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4192, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4192, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4090, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4090, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_MULT", 1, 2, 2, 1); __PYX_ERR(4, 4090, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_MULT") < 0)) __PYX_ERR(4, 4090, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4192, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4192, __pyx_L3_error) } __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_MULT", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 4090, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_MULT", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 4192, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_MULT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 4092, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 4092, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_600stream_MULT(__pyx_self, __pyx_v_real0, __pyx_v_real1); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 4194, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 4194, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_612stream_MULT(__pyx_self, __pyx_v_real0, __pyx_v_real1); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { +static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real0_data; @@ -86379,8 +73754,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MULT(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -86388,35 +73762,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MULT(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4111, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4112, __pyx_L1_error) - __pyx_v_real0_data = ((double *)__pyx_t_2); + __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4113, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4114, __pyx_L1_error) - __pyx_v_real1_data = ((double *)__pyx_t_2); + __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4115, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_MULT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MULT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4118, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MULT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4119, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -86438,16 +73810,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MULT(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_603stream_NATR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_615stream_NATR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_602stream_NATR, " NATR(high, low, close[, timeperiod=?])\n\n Normalized Average True Range (Volatility Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_603stream_NATR = {"stream_NATR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_603stream_NATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_602stream_NATR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_603stream_NATR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -86470,7 +73842,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_NATR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -86478,69 +73850,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4223, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4223, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4223, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4223, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4121, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4121, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, 1); __PYX_ERR(4, 4121, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4121, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, 2); __PYX_ERR(4, 4121, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4121, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_NATR") < 0)) __PYX_ERR(4, 4121, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4223, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4223, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4223, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4223, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -86549,48 +73900,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4123, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4225, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 4121, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 4223, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_NATR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4123, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4123, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4123, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_602stream_NATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4225, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4225, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4225, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_614stream_NATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -86602,8 +73952,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_NATR(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -86612,43 +73961,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_NATR(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4144, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4145, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4146, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4147, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4148, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4149, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4150, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_NATR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_NATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4153, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_NATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4154, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -86671,16 +74017,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_NATR(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_605stream_OBV(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_617stream_OBV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_604stream_OBV, " OBV(real, volume)\n\n On Balance Volume (Volume Indicators)\n\n Inputs:\n real: (any ndarray)\n prices: ['volume']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_605stream_OBV = {"stream_OBV", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_605stream_OBV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_604stream_OBV}; -static PyObject *__pyx_pw_5talib_7_ta_lib_605stream_OBV(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -86701,7 +74047,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_OBV (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -86709,86 +74055,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_volume,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4258, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4258, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4156, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_volume)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4156, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_OBV", 1, 2, 2, 1); __PYX_ERR(4, 4156, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_OBV") < 0)) __PYX_ERR(4, 4156, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4258, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4258, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); __pyx_v_volume = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_OBV", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 4156, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_OBV", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 4258, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_OBV", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4158, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 4158, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_604stream_OBV(__pyx_self, __pyx_v_real, __pyx_v_volume); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4260, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(5, 4260, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_616stream_OBV(__pyx_self, __pyx_v_real, __pyx_v_volume); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume) { +static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -86799,8 +74132,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_OBV(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -86808,35 +74140,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_OBV(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_real); __Pyx_INCREF((PyObject *)__pyx_v_volume); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4177, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4178, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4179, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4180, __pyx_L1_error) - __pyx_v_volume_data = ((double *)__pyx_t_2); + __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4181, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_OBV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_volume_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_OBV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4184, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_OBV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4185, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -86858,16 +74188,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_OBV(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_607stream_PLUS_DI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_619stream_PLUS_DI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_606stream_PLUS_DI, " PLUS_DI(high, low, close[, timeperiod=?])\n\n Plus Directional Indicator (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_607stream_PLUS_DI = {"stream_PLUS_DI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_607stream_PLUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_606stream_PLUS_DI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_607stream_PLUS_DI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -86890,7 +74220,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_PLUS_DI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -86898,69 +74228,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4289, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4289, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4289, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4289, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4187, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4187, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, 1); __PYX_ERR(4, 4187, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4187, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, 2); __PYX_ERR(4, 4187, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4187, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_PLUS_DI") < 0)) __PYX_ERR(4, 4187, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4289, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4289, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4289, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4289, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -86969,48 +74278,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4189, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4291, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 4187, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 4289, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4189, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4189, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4189, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4291, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4291, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4291, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_618stream_PLUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -87022,8 +74330,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(CYTHON_UNUSED PyObje PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -87032,43 +74339,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(CYTHON_UNUSED PyObje __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4210, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4312, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4211, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4212, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4213, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4214, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4215, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4216, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_PLUS_DI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PLUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4219, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PLUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4220, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -87091,16 +74395,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_609stream_PLUS_DM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_621stream_PLUS_DM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_608stream_PLUS_DM, " PLUS_DM(high, low[, timeperiod=?])\n\n Plus Directional Movement (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_609stream_PLUS_DM = {"stream_PLUS_DM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_609stream_PLUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_608stream_PLUS_DM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_609stream_PLUS_DM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -87122,7 +74426,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_PLUS_DM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -87130,56 +74434,42 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4324, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4324, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4324, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4222, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4222, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_PLUS_DM", 0, 2, 3, 1); __PYX_ERR(4, 4222, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4222, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_PLUS_DM") < 0)) __PYX_ERR(4, 4222, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4324, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4324, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4324, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -87187,47 +74477,46 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4224, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4326, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_PLUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 4222, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_PLUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 4324, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4224, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4224, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4326, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4326, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_620stream_PLUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -87238,8 +74527,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(CYTHON_UNUSED PyObje PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -87247,35 +74535,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(CYTHON_UNUSED PyObje __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4244, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4245, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4246, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4247, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4248, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_PLUS_DM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PLUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4251, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PLUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4252, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4354, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -87297,16 +74583,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_611stream_PPO(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_623stream_PPO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_610stream_PPO, " PPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\n Percentage Price Oscillator (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_611stream_PPO = {"stream_PPO", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_611stream_PPO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_610stream_PPO}; -static PyObject *__pyx_pw_5talib_7_ta_lib_611stream_PPO(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -87329,7 +74615,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_PPO (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -87337,121 +74623,107 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4356, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4356, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4356, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4356, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4254, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4254, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowperiod); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4254, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_matype); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4254, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_PPO") < 0)) __PYX_ERR(4, 4254, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4356, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4356, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4356, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4356, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4256, __pyx_L3_error) + __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4358, __pyx_L3_error) } else { __pyx_v_fastperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4256, __pyx_L3_error) + __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4358, __pyx_L3_error) } else { __pyx_v_slowperiod = ((int)((int)-2147483648)); } if (values[3]) { - __pyx_v_matype = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4256, __pyx_L3_error) + __pyx_v_matype = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4358, __pyx_L3_error) } else { __pyx_v_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_PPO", 0, 1, 4, __pyx_nargs); __PYX_ERR(4, 4254, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_PPO", 0, 1, 4, __pyx_nargs); __PYX_ERR(5, 4356, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_PPO", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4256, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_610stream_PPO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4358, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_622stream_PPO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -87461,35 +74733,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_PPO(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_PPO", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4277, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4278, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4279, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_PPO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PPO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4282, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PPO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4283, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4385, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -87510,16 +74778,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_PPO(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_613stream_ROC(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_625stream_ROC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_612stream_ROC, " ROC(real[, timeperiod=?])\n\n Rate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_613stream_ROC = {"stream_ROC", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_613stream_ROC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_612stream_ROC}; -static PyObject *__pyx_pw_5talib_7_ta_lib_613stream_ROC(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -87540,7 +74808,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ROC (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -87548,89 +74816,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4387, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4387, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4285, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4285, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ROC") < 0)) __PYX_ERR(4, 4285, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4387, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4387, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4287, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4389, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ROC", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4285, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ROC", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4387, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ROC", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4287, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_612stream_ROC(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4389, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_624stream_ROC(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -87640,35 +74900,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_ROC(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_ROC", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4306, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4307, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4308, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_ROC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4311, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4312, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4414, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -87689,16 +74945,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_ROC(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_615stream_ROCP(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_627stream_ROCP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_614stream_ROCP, " ROCP(real[, timeperiod=?])\n\n Rate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_615stream_ROCP = {"stream_ROCP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_615stream_ROCP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_614stream_ROCP}; -static PyObject *__pyx_pw_5talib_7_ta_lib_615stream_ROCP(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -87719,7 +74975,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ROCP (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -87727,89 +74983,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4416, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4416, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4314, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4314, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ROCP") < 0)) __PYX_ERR(4, 4314, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4416, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4416, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4316, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4418, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ROCP", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4314, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ROCP", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4416, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4316, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_614stream_ROCP(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4418, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_626stream_ROCP(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -87819,35 +75067,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_ROCP(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_ROCP", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4335, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4336, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4337, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_ROCP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4340, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4442, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4341, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4443, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -87868,16 +75112,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_ROCP(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_617stream_ROCR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_629stream_ROCR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_616stream_ROCR, " ROCR(real[, timeperiod=?])\n\n Rate of change ratio: (real/prevPrice) (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_617stream_ROCR = {"stream_ROCR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_617stream_ROCR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_616stream_ROCR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_617stream_ROCR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -87898,7 +75142,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ROCR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -87906,89 +75150,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4445, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4445, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4343, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4343, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ROCR") < 0)) __PYX_ERR(4, 4343, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4445, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4445, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4345, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4447, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ROCR", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4343, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ROCR", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4445, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4345, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_616stream_ROCR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4447, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_628stream_ROCR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -87998,35 +75234,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_ROCR(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_ROCR", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4364, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4365, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4366, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_ROCR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4369, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4370, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -88047,16 +75279,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_ROCR(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_619stream_ROCR100(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_631stream_ROCR100(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_618stream_ROCR100, " ROCR100(real[, timeperiod=?])\n\n Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 10\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_619stream_ROCR100 = {"stream_ROCR100", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_619stream_ROCR100, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_618stream_ROCR100}; -static PyObject *__pyx_pw_5talib_7_ta_lib_619stream_ROCR100(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -88077,7 +75309,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ROCR100 (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -88085,89 +75317,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4474, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4474, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4372, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4372, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ROCR100") < 0)) __PYX_ERR(4, 4372, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4474, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4474, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4374, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4476, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ROCR100", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4372, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ROCR100", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4474, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4374, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_618stream_ROCR100(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4476, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_630stream_ROCR100(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -88177,35 +75401,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_ROCR100(CYTHON_UNUSED PyObje PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_ROCR100", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4393, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4394, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4395, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_ROCR100((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCR100, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4398, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCR100, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4399, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4501, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -88226,16 +75446,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_ROCR100(CYTHON_UNUSED PyObje /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_621stream_RSI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_633stream_RSI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_620stream_RSI, " RSI(real[, timeperiod=?])\n\n Relative Strength Index (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_621stream_RSI = {"stream_RSI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_621stream_RSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_620stream_RSI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_621stream_RSI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -88256,7 +75476,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_RSI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -88264,89 +75484,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4503, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4503, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4401, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4401, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_RSI") < 0)) __PYX_ERR(4, 4401, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4503, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4503, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4403, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4505, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_RSI", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4401, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_RSI", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4503, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_RSI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4403, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_620stream_RSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4505, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_632stream_RSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -88356,35 +75568,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_RSI(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_RSI", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4422, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4423, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4424, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_RSI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_RSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4427, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_RSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4428, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -88405,16 +75613,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_RSI(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_623stream_SAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_635stream_SAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_622stream_SAR, " SAR(high, low[, acceleration=?, maximum=?])\n\n Parabolic SAR (Overlap Studies)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\n acceleration: 0.02\n maximum: 0.2\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_623stream_SAR = {"stream_SAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_623stream_SAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_622stream_SAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_623stream_SAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -88437,7 +75645,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_SAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -88445,67 +75653,50 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_acceleration,&__pyx_n_s_maximum,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4532, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4532, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4532, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4532, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4430, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4430, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_SAR", 0, 2, 4, 1); __PYX_ERR(4, 4430, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_acceleration); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4430, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maximum); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4430, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_SAR") < 0)) __PYX_ERR(4, 4430, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4532, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4532, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4532, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4532, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -88513,52 +75704,51 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_acceleration = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_acceleration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4432, __pyx_L3_error) + __pyx_v_acceleration = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_acceleration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4534, __pyx_L3_error) } else { __pyx_v_acceleration = ((double)((double)0.02)); } if (values[3]) { - __pyx_v_maximum = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_maximum == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4432, __pyx_L3_error) + __pyx_v_maximum = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_maximum == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4534, __pyx_L3_error) } else { __pyx_v_maximum = ((double)((double)0.2)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_SAR", 0, 2, 4, __pyx_nargs); __PYX_ERR(4, 4430, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_SAR", 0, 2, 4, __pyx_nargs); __PYX_ERR(5, 4532, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_SAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4432, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4432, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_622stream_SAR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_acceleration, __pyx_v_maximum); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4534, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4534, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_634stream_SAR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_acceleration, __pyx_v_maximum); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum) { +static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -88569,8 +75759,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_SAR(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -88578,35 +75767,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_SAR(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4453, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4454, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4455, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4456, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4457, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_SAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_acceleration, __pyx_v_maximum, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4460, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4562, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4461, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -88628,16 +75815,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_SAR(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_625stream_SAREXT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_637stream_SAREXT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_624stream_SAREXT, " SAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\n Parabolic SAR - Extended (Overlap Studies)\n\n Inputs:\n prices: ['high', 'low']\n Parameters:\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\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_625stream_SAREXT = {"stream_SAREXT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_625stream_SAREXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_624stream_SAREXT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_625stream_SAREXT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -88666,7 +75853,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_SAREXT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -88674,133 +75861,98 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_startvalue,&__pyx_n_s_offsetonreverse,&__pyx_n_s_accelerationinitlong,&__pyx_n_s_accelerationlong,&__pyx_n_s_accelerationmaxlong,&__pyx_n_s_accelerationinitshort,&__pyx_n_s_accelerationshort,&__pyx_n_s_accelerationmaxshort,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_SAREXT", 0, 2, 10, 1); __PYX_ERR(4, 4463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_startvalue); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_offsetonreverse); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationinitlong); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationlong); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 6: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationmaxlong); - if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 7: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationinitshort); - if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 8: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationshort); - if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 9: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_accelerationmaxshort); - if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4463, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_SAREXT") < 0)) __PYX_ERR(4, 4463, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4565, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4565, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4565, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -88808,82 +75960,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); if (values[2]) { - __pyx_v_startvalue = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_startvalue == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4465, __pyx_L3_error) + __pyx_v_startvalue = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_startvalue == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error) } else { __pyx_v_startvalue = ((double)((double)-4e37)); } if (values[3]) { - __pyx_v_offsetonreverse = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_offsetonreverse == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4465, __pyx_L3_error) + __pyx_v_offsetonreverse = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_offsetonreverse == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error) } else { __pyx_v_offsetonreverse = ((double)((double)-4e37)); } if (values[4]) { - __pyx_v_accelerationinitlong = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_accelerationinitlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4465, __pyx_L3_error) + __pyx_v_accelerationinitlong = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_accelerationinitlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error) } else { __pyx_v_accelerationinitlong = ((double)((double)-4e37)); } if (values[5]) { - __pyx_v_accelerationlong = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_accelerationlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4465, __pyx_L3_error) + __pyx_v_accelerationlong = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_accelerationlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error) } else { __pyx_v_accelerationlong = ((double)((double)-4e37)); } if (values[6]) { - __pyx_v_accelerationmaxlong = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_accelerationmaxlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4465, __pyx_L3_error) + __pyx_v_accelerationmaxlong = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_accelerationmaxlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error) } else { __pyx_v_accelerationmaxlong = ((double)((double)-4e37)); } if (values[7]) { - __pyx_v_accelerationinitshort = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_accelerationinitshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4465, __pyx_L3_error) + __pyx_v_accelerationinitshort = __Pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_accelerationinitshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error) } else { __pyx_v_accelerationinitshort = ((double)((double)-4e37)); } if (values[8]) { - __pyx_v_accelerationshort = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_accelerationshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4465, __pyx_L3_error) + __pyx_v_accelerationshort = __Pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_accelerationshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error) } else { __pyx_v_accelerationshort = ((double)((double)-4e37)); } if (values[9]) { - __pyx_v_accelerationmaxshort = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_accelerationmaxshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4465, __pyx_L3_error) + __pyx_v_accelerationmaxshort = __Pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_accelerationmaxshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error) } else { __pyx_v_accelerationmaxshort = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_SAREXT", 0, 2, 10, __pyx_nargs); __PYX_ERR(4, 4463, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_SAREXT", 0, 2, 10, __pyx_nargs); __PYX_ERR(5, 4565, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4465, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4465, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_624stream_SAREXT(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4567, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4567, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_636stream_SAREXT(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort) { +static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -88894,8 +76045,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObjec PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -88903,35 +76053,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObjec __Pyx_INCREF((PyObject *)__pyx_v_high); __Pyx_INCREF((PyObject *)__pyx_v_low); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4492, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4493, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4494, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4495, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4496, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_SAREXT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SAREXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4499, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SAREXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4500, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -88953,16 +76101,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_627stream_SIN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_639stream_SIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_626stream_SIN, " SIN(real)\n\n Vector Trigonometric Sin (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_627stream_SIN = {"stream_SIN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_627stream_SIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_626stream_SIN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_627stream_SIN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -88982,7 +76130,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_SIN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -88990,71 +76138,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4604, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4502, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_SIN") < 0)) __PYX_ERR(4, 4502, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4604, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_SIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4502, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_SIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4604, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_SIN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4504, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_626stream_SIN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4606, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_638stream_SIN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -89064,35 +76206,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_SIN(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_SIN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4521, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4623, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4523, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_SIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4526, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4527, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -89113,16 +76251,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_SIN(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_629stream_SINH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_641stream_SINH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_628stream_SINH, " SINH(real)\n\n Vector Trigonometric Sinh (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_629stream_SINH = {"stream_SINH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_629stream_SINH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_628stream_SINH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_629stream_SINH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -89142,7 +76280,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_SINH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -89150,71 +76288,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4631, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4529, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_SINH") < 0)) __PYX_ERR(4, 4529, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4631, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_SINH", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4529, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_SINH", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4631, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_SINH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4531, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_628stream_SINH(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4633, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_640stream_SINH(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -89224,35 +76356,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_SINH(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_SINH", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4548, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4650, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4549, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4550, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_SINH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SINH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4553, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SINH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4655, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4554, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -89273,16 +76401,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_SINH(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_631stream_SMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_643stream_SMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_630stream_SMA, " SMA(real[, timeperiod=?])\n\n Simple Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_631stream_SMA = {"stream_SMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_631stream_SMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_630stream_SMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_631stream_SMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -89303,7 +76431,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_SMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -89311,89 +76439,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4658, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4658, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4556, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4556, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_SMA") < 0)) __PYX_ERR(4, 4556, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4658, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4658, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4558, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4660, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_SMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4556, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_SMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4658, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_SMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4558, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_630stream_SMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4660, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_642stream_SMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -89403,35 +76523,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_SMA(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_SMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4577, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4578, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4579, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_SMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4582, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4583, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -89452,16 +76568,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_SMA(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_633stream_SQRT(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_645stream_SQRT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_632stream_SQRT, " SQRT(real)\n\n Vector Square Root (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_633stream_SQRT = {"stream_SQRT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_633stream_SQRT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_632stream_SQRT}; -static PyObject *__pyx_pw_5talib_7_ta_lib_633stream_SQRT(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -89481,7 +76597,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_SQRT (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -89489,71 +76605,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4687, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4585, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_SQRT") < 0)) __PYX_ERR(4, 4585, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4687, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_SQRT", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4585, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_SQRT", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4687, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_SQRT", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4587, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_632stream_SQRT(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4689, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_644stream_SQRT(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -89563,35 +76673,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_SQRT(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_SQRT", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4604, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4605, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4606, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_SQRT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SQRT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4609, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SQRT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4610, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4712, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -89612,16 +76718,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_SQRT(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_635stream_STDDEV(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_647stream_STDDEV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_634stream_STDDEV, " STDDEV(real[, timeperiod=?, nbdev=?])\n\n Standard Deviation (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 5\n nbdev: 1.0\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_635stream_STDDEV = {"stream_STDDEV", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_635stream_STDDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_634stream_STDDEV}; -static PyObject *__pyx_pw_5talib_7_ta_lib_635stream_STDDEV(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -89643,7 +76749,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_STDDEV (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -89651,105 +76757,94 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdev,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4714, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4714, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4714, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4612, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4612, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nbdev); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4612, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_STDDEV") < 0)) __PYX_ERR(4, 4612, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4714, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4714, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4714, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4614, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4716, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_nbdev = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4614, __pyx_L3_error) + __pyx_v_nbdev = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4716, __pyx_L3_error) } else { __pyx_v_nbdev = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_STDDEV", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 4612, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_STDDEV", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 4714, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4614, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_634stream_STDDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4716, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_646stream_STDDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) { +static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -89759,35 +76854,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_STDDEV(CYTHON_UNUSED PyObjec PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_STDDEV", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4634, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4635, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4636, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_STDDEV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STDDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4639, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STDDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4741, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4640, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -89808,16 +76899,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_STDDEV(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_637stream_STOCH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_649stream_STOCH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_636stream_STOCH, " STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\n Stochastic (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n fastk_period: 5\n slowk_period: 3\n slowk_matype: 0\n slowd_period: 3\n slowd_matype: 0\n Outputs:\n slowk\n slowd\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_637stream_STOCH = {"stream_STOCH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_637stream_STOCH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_636stream_STOCH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_637stream_STOCH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -89844,7 +76935,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_STOCH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -89852,113 +76943,80 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_fastk_period,&__pyx_n_s_slowk_period,&__pyx_n_s_slowk_matype,&__pyx_n_s_slowd_period,&__pyx_n_s_slowd_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4642, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4642, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, 1); __PYX_ERR(4, 4642, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4642, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, 2); __PYX_ERR(4, 4642, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastk_period); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4642, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowk_period); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4642, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowk_matype); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4642, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 6: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowd_period); - if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4642, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 7: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_slowd_matype); - if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4642, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_STOCH") < 0)) __PYX_ERR(4, 4642, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4744, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4744, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4744, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4744, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -89967,68 +77025,67 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4644, __pyx_L3_error) + __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error) } else { __pyx_v_fastk_period = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_slowk_period = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_slowk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4644, __pyx_L3_error) + __pyx_v_slowk_period = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_slowk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error) } else { __pyx_v_slowk_period = ((int)((int)-2147483648)); } if (values[5]) { - __pyx_v_slowk_matype = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_slowk_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4644, __pyx_L3_error) + __pyx_v_slowk_matype = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_slowk_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error) } else { __pyx_v_slowk_matype = ((int)((int)0)); } if (values[6]) { - __pyx_v_slowd_period = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_slowd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4644, __pyx_L3_error) + __pyx_v_slowd_period = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_slowd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error) } else { __pyx_v_slowd_period = ((int)((int)-2147483648)); } if (values[7]) { - __pyx_v_slowd_matype = __Pyx_PyInt_As_int(values[7]); if (unlikely((__pyx_v_slowd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4644, __pyx_L3_error) + __pyx_v_slowd_matype = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_slowd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error) } else { __pyx_v_slowd_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, __pyx_nargs); __PYX_ERR(4, 4642, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, __pyx_nargs); __PYX_ERR(5, 4744, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4644, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4644, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4644, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_636stream_STOCH(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4746, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4746, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4746, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_648stream_STOCH(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -90041,10 +77098,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_STOCH(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -90053,32 +77109,29 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_STOCH(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4671, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4773, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4672, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4673, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4775, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4674, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4675, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4777, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4676, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4677, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; @@ -90086,33 +77139,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_STOCH(CYTHON_UNUSED PyObject __pyx_v_retCode = TA_STOCH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outslowk), (&__pyx_v_outslowd)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4681, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4783, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outslowk); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4682, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outslowk); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outslowd); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4682, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outslowd); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 4682, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(4, 4682, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(4, 4682, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4784, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(5, 4784, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("talib._ta_lib.stream_STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -90126,16 +77179,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_STOCH(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_639stream_STOCHF(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_651stream_STOCHF(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_638stream_STOCHF, " STOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\n Stochastic Fast (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\n Outputs:\n fastk\n fastd\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_639stream_STOCHF = {"stream_STOCHF", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_639stream_STOCHF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_638stream_STOCHF}; -static PyObject *__pyx_pw_5talib_7_ta_lib_639stream_STOCHF(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -90160,7 +77213,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_STOCHF (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -90168,91 +77221,64 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_fastk_period,&__pyx_n_s_fastd_period,&__pyx_n_s_fastd_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4786, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4786, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4786, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4786, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4786, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4786, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4684, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4684, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, 1); __PYX_ERR(4, 4684, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4684, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, 2); __PYX_ERR(4, 4684, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastk_period); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4684, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastd_period); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4684, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastd_matype); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4684, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_STOCHF") < 0)) __PYX_ERR(4, 4684, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4786, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4786, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4786, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4786, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4786, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4786, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -90261,58 +77287,57 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4686, __pyx_L3_error) + __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4788, __pyx_L3_error) } else { __pyx_v_fastk_period = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_fastd_period = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4686, __pyx_L3_error) + __pyx_v_fastd_period = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4788, __pyx_L3_error) } else { __pyx_v_fastd_period = ((int)((int)-2147483648)); } if (values[5]) { - __pyx_v_fastd_matype = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4686, __pyx_L3_error) + __pyx_v_fastd_matype = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4788, __pyx_L3_error) } else { __pyx_v_fastd_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, __pyx_nargs); __PYX_ERR(4, 4684, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, __pyx_nargs); __PYX_ERR(5, 4786, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4686, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4686, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4686, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_638stream_STOCHF(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4788, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4788, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4788, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_650stream_STOCHF(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -90325,10 +77350,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_STOCHF(CYTHON_UNUSED PyObjec PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -90337,32 +77361,29 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_STOCHF(CYTHON_UNUSED PyObjec __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4711, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4712, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4713, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4714, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4715, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4716, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4717, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; @@ -90370,33 +77391,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_STOCHF(CYTHON_UNUSED PyObjec __pyx_v_retCode = TA_STOCHF((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outfastk), (&__pyx_v_outfastd)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCHF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4721, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCHF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4823, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outfastk); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4722, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outfastk); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outfastd); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4722, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outfastd); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4824, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 4722, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(4, 4722, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(4, 4722, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4824, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(5, 4824, __pyx_L1_error); __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("talib._ta_lib.stream_STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -90410,16 +77431,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_STOCHF(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_641stream_STOCHRSI(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_653stream_STOCHRSI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_640stream_STOCHRSI, " STOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\n Stochastic Relative Strength Index (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\n Outputs:\n fastk\n fastd\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_641stream_STOCHRSI = {"stream_STOCHRSI", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_641stream_STOCHRSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_640stream_STOCHRSI}; -static PyObject *__pyx_pw_5talib_7_ta_lib_641stream_STOCHRSI(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -90443,7 +77464,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_STOCHRSI (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -90451,137 +77472,120 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_fastk_period,&__pyx_n_s_fastd_period,&__pyx_n_s_fastd_matype,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4826, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4826, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4826, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4826, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4826, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4724, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4724, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastk_period); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4724, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastd_period); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4724, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fastd_matype); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4724, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_STOCHRSI") < 0)) __PYX_ERR(4, 4724, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4826, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4826, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4826, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4826, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4826, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4726, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4828, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4726, __pyx_L3_error) + __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4828, __pyx_L3_error) } else { __pyx_v_fastk_period = ((int)((int)-2147483648)); } if (values[3]) { - __pyx_v_fastd_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4726, __pyx_L3_error) + __pyx_v_fastd_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4828, __pyx_L3_error) } else { __pyx_v_fastd_period = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_fastd_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4726, __pyx_L3_error) + __pyx_v_fastd_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4828, __pyx_L3_error) } else { __pyx_v_fastd_matype = ((int)((int)0)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_STOCHRSI", 0, 1, 5, __pyx_nargs); __PYX_ERR(4, 4724, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_STOCHRSI", 0, 1, 5, __pyx_nargs); __PYX_ERR(5, 4826, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4726, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4828, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_652stream_STOCHRSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) { +static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -90592,26 +77596,22 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_STOCHRSI", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4750, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4751, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4752, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outfastk = __pyx_v_5talib_7_ta_lib_NaN; @@ -90619,33 +77619,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(CYTHON_UNUSED PyObj __pyx_v_retCode = TA_STOCHRSI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outfastk), (&__pyx_v_outfastd)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCHRSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4756, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCHRSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4858, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outfastk); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4757, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outfastk); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4859, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outfastd); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4757, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 4757, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outfastd); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(4, 4757, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(4, 4757, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4859, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 4859, __pyx_L1_error); __pyx_t_1 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("talib._ta_lib.stream_STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -90657,16 +77657,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_643stream_SUB(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_655stream_SUB(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_642stream_SUB, " SUB(real0, real1)\n\n Vector Arithmetic Subtraction (Math Operators)\n\n Inputs:\n real0: (any ndarray)\n real1: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_643stream_SUB = {"stream_SUB", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_643stream_SUB, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_642stream_SUB}; -static PyObject *__pyx_pw_5talib_7_ta_lib_643stream_SUB(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -90687,7 +77687,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_SUB (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -90695,86 +77695,73 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4861, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4861, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real0)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4759, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real1)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4759, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_SUB", 1, 2, 2, 1); __PYX_ERR(4, 4759, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_SUB") < 0)) __PYX_ERR(4, 4759, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4861, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4861, __pyx_L3_error) } __pyx_v_real0 = ((PyArrayObject *)values[0]); __pyx_v_real1 = ((PyArrayObject *)values[1]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_SUB", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 4759, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_SUB", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 4861, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_SUB", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 4761, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 4761, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_642stream_SUB(__pyx_self, __pyx_v_real0, __pyx_v_real1); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 4863, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 4863, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_654stream_SUB(__pyx_self, __pyx_v_real0, __pyx_v_real1); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { +static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real0_data; @@ -90785,8 +77772,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -90794,35 +77780,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject * __Pyx_INCREF((PyObject *)__pyx_v_real0); __Pyx_INCREF((PyObject *)__pyx_v_real1); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4780, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4781, __pyx_L1_error) - __pyx_v_real0_data = ((double *)__pyx_t_2); + __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4782, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4783, __pyx_L1_error) - __pyx_v_real1_data = ((double *)__pyx_t_2); + __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4784, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_SUB((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SUB, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4787, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SUB, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4788, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -90844,16 +77828,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_645stream_SUM(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_657stream_SUM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_644stream_SUM, " SUM(real[, timeperiod=?])\n\n Summation (Math Operators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_645stream_SUM = {"stream_SUM", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_645stream_SUM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_644stream_SUM}; -static PyObject *__pyx_pw_5talib_7_ta_lib_645stream_SUM(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -90874,7 +77858,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_SUM (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -90882,89 +77866,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4892, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4892, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4790, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4790, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_SUM") < 0)) __PYX_ERR(4, 4790, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4892, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4892, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4792, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4894, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_SUM", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4790, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_SUM", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4892, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_SUM", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4792, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_644stream_SUM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4894, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_656stream_SUM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -90974,35 +77950,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SUM(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_SUM", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4811, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4812, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4813, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_SUM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SUM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4816, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SUM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4918, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4817, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4919, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -91023,16 +77995,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SUM(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_647stream_T3(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_659stream_T3(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_646stream_T3, " T3(real[, timeperiod=?, vfactor=?])\n\n Triple Exponential Moving Average (T3) (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 5\n vfactor: 0.7\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_647stream_T3 = {"stream_T3", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_647stream_T3, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_646stream_T3}; -static PyObject *__pyx_pw_5talib_7_ta_lib_647stream_T3(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -91054,7 +78026,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_T3 (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -91062,105 +78034,94 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_vfactor,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4921, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4921, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4921, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4819, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4819, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vfactor); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4819, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_T3") < 0)) __PYX_ERR(4, 4819, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4921, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4921, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4921, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4821, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4923, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_vfactor = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vfactor == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4821, __pyx_L3_error) + __pyx_v_vfactor = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vfactor == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4923, __pyx_L3_error) } else { __pyx_v_vfactor = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_T3", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 4819, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_T3", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 4921, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_T3", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4821, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_646stream_T3(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_vfactor); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4923, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_658stream_T3(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_vfactor); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor) { +static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -91170,35 +78131,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_T3(CYTHON_UNUSED PyObject *_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_T3", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4841, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4943, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4842, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4843, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_T3((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_vfactor, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_T3, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4846, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_T3, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4948, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4847, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -91219,16 +78176,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_T3(CYTHON_UNUSED PyObject *_ /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_649stream_TAN(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_661stream_TAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_648stream_TAN, " TAN(real)\n\n Vector Trigonometric Tan (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_649stream_TAN = {"stream_TAN", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_649stream_TAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_648stream_TAN}; -static PyObject *__pyx_pw_5talib_7_ta_lib_649stream_TAN(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -91248,7 +78205,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_TAN (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -91256,71 +78213,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4951, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4849, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_TAN") < 0)) __PYX_ERR(4, 4849, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4951, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_TAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4849, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_TAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4951, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_TAN", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4851, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_648stream_TAN(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4953, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_660stream_TAN(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -91330,35 +78281,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_TAN(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_TAN", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4868, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4970, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4869, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4870, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_TAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4873, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4975, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4874, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -91379,16 +78326,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_TAN(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_651stream_TANH(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_663stream_TANH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_650stream_TANH, " TANH(real)\n\n Vector Trigonometric Tanh (Math Transform)\n\n Inputs:\n real: (any ndarray)\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_651stream_TANH = {"stream_TANH", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_651stream_TANH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_650stream_TANH}; -static PyObject *__pyx_pw_5talib_7_ta_lib_651stream_TANH(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -91408,7 +78355,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_TANH (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -91416,71 +78363,65 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4978, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4876, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_TANH") < 0)) __PYX_ERR(4, 4876, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4978, __pyx_L3_error) } __pyx_v_real = ((PyArrayObject *)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_TANH", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4876, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_TANH", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4978, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_TANH", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4878, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_650stream_TANH(__pyx_self, __pyx_v_real); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4980, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_662stream_TANH(__pyx_self, __pyx_v_real); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { +static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -91490,35 +78431,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_TANH(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_TANH", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4895, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4896, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4897, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_TANH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TANH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4900, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TANH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5002, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4901, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -91539,16 +78476,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_TANH(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_653stream_TEMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_665stream_TEMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_652stream_TEMA, " TEMA(real[, timeperiod=?])\n\n Triple Exponential Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_653stream_TEMA = {"stream_TEMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_653stream_TEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_652stream_TEMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_653stream_TEMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -91569,7 +78506,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_TEMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -91577,89 +78514,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5005, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5005, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4903, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4903, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_TEMA") < 0)) __PYX_ERR(4, 4903, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5005, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5005, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4905, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5007, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_TEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4903, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_TEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5005, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4905, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_652stream_TEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5007, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_664stream_TEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -91669,35 +78598,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_TEMA(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_TEMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4924, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5026, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4925, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4926, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_TEMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4929, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5031, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4930, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5032, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -91718,16 +78643,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_TEMA(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_655stream_TRANGE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_667stream_TRANGE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_654stream_TRANGE, " TRANGE(high, low, close)\n\n True Range (Volatility Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_655stream_TRANGE = {"stream_TRANGE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_655stream_TRANGE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_654stream_TRANGE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_655stream_TRANGE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -91749,7 +78674,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_TRANGE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -91757,59 +78682,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5034, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5034, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5034, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4932, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4932, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, 1); __PYX_ERR(4, 4932, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4932, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, 2); __PYX_ERR(4, 4932, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_TRANGE") < 0)) __PYX_ERR(4, 4932, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5034, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5034, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5034, __pyx_L3_error) } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); @@ -91817,41 +78723,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, __pyx_nargs); __PYX_ERR(4, 4932, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, __pyx_nargs); __PYX_ERR(5, 5034, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4934, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4934, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4934, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_654stream_TRANGE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5036, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5036, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5036, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_666stream_TRANGE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -91863,8 +78768,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObjec PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -91873,43 +78777,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObjec __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4953, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5055, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4954, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4955, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5057, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4956, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4957, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5059, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4958, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 4959, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_TRANGE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRANGE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4962, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRANGE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4963, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5065, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -91932,16 +78833,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_657stream_TRIMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_669stream_TRIMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_656stream_TRIMA, " TRIMA(real[, timeperiod=?])\n\n Triangular Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_657stream_TRIMA = {"stream_TRIMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_657stream_TRIMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_656stream_TRIMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_657stream_TRIMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -91962,7 +78863,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_TRIMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -91970,89 +78871,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5067, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5067, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4965, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4965, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_TRIMA") < 0)) __PYX_ERR(4, 4965, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5067, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5067, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4967, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5069, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_TRIMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4965, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_TRIMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5067, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4967, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_656stream_TRIMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5069, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_668stream_TRIMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -92062,35 +78955,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_TRIMA(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_TRIMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4986, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5088, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4987, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 4988, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_TRIMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRIMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4991, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRIMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5093, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4992, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5094, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -92111,16 +79000,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_TRIMA(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_659stream_TRIX(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_671stream_TRIX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_658stream_TRIX, " TRIX(real[, timeperiod=?])\n\n 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_659stream_TRIX = {"stream_TRIX", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_659stream_TRIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_658stream_TRIX}; -static PyObject *__pyx_pw_5talib_7_ta_lib_659stream_TRIX(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -92141,7 +79030,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_TRIX (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -92149,89 +79038,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5096, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5096, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4994, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 4994, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_TRIX") < 0)) __PYX_ERR(4, 4994, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5096, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5096, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4996, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5098, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_TRIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4994, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_TRIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5096, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4996, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_658stream_TRIX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5098, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_670stream_TRIX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -92241,35 +79122,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_TRIX(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_TRIX", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5015, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5016, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5017, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_TRIX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5020, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5021, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -92290,16 +79167,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_TRIX(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_661stream_TSF(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_673stream_TSF(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_660stream_TSF, " TSF(real[, timeperiod=?])\n\n Time Series Forecast (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_661stream_TSF = {"stream_TSF", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_661stream_TSF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_660stream_TSF}; -static PyObject *__pyx_pw_5talib_7_ta_lib_661stream_TSF(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -92320,7 +79197,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_TSF (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -92328,89 +79205,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5125, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5125, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5023, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5023, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_TSF") < 0)) __PYX_ERR(4, 5023, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5125, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5125, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5025, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5127, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_TSF", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5023, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_TSF", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5125, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_TSF", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5025, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_660stream_TSF(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5127, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_672stream_TSF(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -92420,35 +79289,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TSF(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_TSF", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5044, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5146, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5045, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5046, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_TSF((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TSF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5049, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TSF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5050, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -92469,16 +79334,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TSF(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_663stream_TYPPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_675stream_TYPPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_662stream_TYPPRICE, " TYPPRICE(high, low, close)\n\n Typical Price (Price Transform)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_663stream_TYPPRICE = {"stream_TYPPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_663stream_TYPPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_662stream_TYPPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_663stream_TYPPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -92500,7 +79365,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_TYPPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -92508,59 +79373,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5154, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5154, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5154, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5052, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5052, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, 1); __PYX_ERR(4, 5052, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5052, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, 2); __PYX_ERR(4, 5052, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_TYPPRICE") < 0)) __PYX_ERR(4, 5052, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5154, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5154, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5154, __pyx_L3_error) } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); @@ -92568,41 +79414,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(4, 5052, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(5, 5154, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5054, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5054, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5054, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5156, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5156, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5156, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_674stream_TYPPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_674stream_TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -92614,8 +79459,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -92624,43 +79468,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5073, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5074, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5075, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5177, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5076, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5077, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5078, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 5079, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_TYPPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TYPPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5082, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TYPPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5083, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5185, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -92683,16 +79524,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_665stream_ULTOSC(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_677stream_ULTOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_664stream_ULTOSC, " ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\n Ultimate Oscillator (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod1: 7\n timeperiod2: 14\n timeperiod3: 28\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_665stream_ULTOSC = {"stream_ULTOSC", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_665stream_ULTOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_664stream_ULTOSC}; -static PyObject *__pyx_pw_5talib_7_ta_lib_665stream_ULTOSC(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -92717,7 +79558,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_ULTOSC (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -92725,91 +79566,64 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod1,&__pyx_n_s_timeperiod2,&__pyx_n_s_timeperiod3,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 5187, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 5187, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 5187, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5187, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5187, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5187, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5085, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5085, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, 1); __PYX_ERR(4, 5085, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5085, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, 2); __PYX_ERR(4, 5085, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod1); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5085, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod2); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5085, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod3); - if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5085, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_ULTOSC") < 0)) __PYX_ERR(4, 5085, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 5187, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 5187, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 5187, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5187, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5187, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5187, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -92818,58 +79632,57 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod1 = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5087, __pyx_L3_error) + __pyx_v_timeperiod1 = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5189, __pyx_L3_error) } else { __pyx_v_timeperiod1 = ((int)((int)-2147483648)); } if (values[4]) { - __pyx_v_timeperiod2 = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_timeperiod2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5087, __pyx_L3_error) + __pyx_v_timeperiod2 = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_timeperiod2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5189, __pyx_L3_error) } else { __pyx_v_timeperiod2 = ((int)((int)-2147483648)); } if (values[5]) { - __pyx_v_timeperiod3 = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_timeperiod3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5087, __pyx_L3_error) + __pyx_v_timeperiod3 = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_timeperiod3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5189, __pyx_L3_error) } else { __pyx_v_timeperiod3 = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, __pyx_nargs); __PYX_ERR(4, 5085, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, __pyx_nargs); __PYX_ERR(5, 5187, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5087, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5087, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5087, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5189, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5189, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5189, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_676stream_ULTOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3) { +static PyObject *__pyx_pf_5talib_7_ta_lib_676stream_ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -92881,8 +79694,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(CYTHON_UNUSED PyObjec PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -92891,43 +79703,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(CYTHON_UNUSED PyObjec __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5110, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5111, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5112, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5113, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5114, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5216, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5115, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 5116, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_ULTOSC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ULTOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5119, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ULTOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5120, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -92950,16 +79759,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(CYTHON_UNUSED PyObjec /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_667stream_VAR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_679stream_VAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_666stream_VAR, " VAR(real[, timeperiod=?, nbdev=?])\n\n Variance (Statistic Functions)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 5\n nbdev: 1.0\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_667stream_VAR = {"stream_VAR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_667stream_VAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_666stream_VAR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_667stream_VAR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -92981,7 +79790,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_VAR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -92989,105 +79798,94 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdev,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5224, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5224, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5224, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5122, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5122, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nbdev); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5122, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_VAR") < 0)) __PYX_ERR(4, 5122, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5224, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5224, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5224, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5124, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5226, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } if (values[2]) { - __pyx_v_nbdev = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 5124, __pyx_L3_error) + __pyx_v_nbdev = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 5226, __pyx_L3_error) } else { __pyx_v_nbdev = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_VAR", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 5122, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_VAR", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 5224, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_VAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5124, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_666stream_VAR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5226, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_678stream_VAR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) { +static PyObject *__pyx_pf_5talib_7_ta_lib_678stream_VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -93097,35 +79895,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_VAR(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_VAR", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5144, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5145, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5146, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_VAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_VAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5149, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_VAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5150, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -93146,16 +79940,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_VAR(CYTHON_UNUSED PyObject * /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_669stream_WCLPRICE(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_681stream_WCLPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_668stream_WCLPRICE, " WCLPRICE(high, low, close)\n\n Weighted Close Price (Price Transform)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_669stream_WCLPRICE = {"stream_WCLPRICE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_669stream_WCLPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_668stream_WCLPRICE}; -static PyObject *__pyx_pw_5talib_7_ta_lib_669stream_WCLPRICE(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -93177,7 +79971,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_WCLPRICE (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -93185,59 +79979,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5254, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5254, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5254, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5152, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5152, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, 1); __PYX_ERR(4, 5152, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5152, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, 2); __PYX_ERR(4, 5152, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_WCLPRICE") < 0)) __PYX_ERR(4, 5152, __pyx_L3_error) + const Py_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) + 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) } } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5254, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5254, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5254, __pyx_L3_error) } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); @@ -93245,41 +80020,40 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(4, 5152, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(5, 5254, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5154, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5154, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5154, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5256, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5256, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5256, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_680stream_WCLPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { +static PyObject *__pyx_pf_5talib_7_ta_lib_680stream_WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -93291,8 +80065,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObj PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -93301,43 +80074,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObj __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5173, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5174, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5175, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5176, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5177, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5178, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 5179, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_WCLPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WCLPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5182, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WCLPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5183, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -93360,16 +80130,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObj /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_671stream_WILLR(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_683stream_WILLR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_670stream_WILLR, " WILLR(high, low, close[, timeperiod=?])\n\n Williams' %R (Momentum Indicators)\n\n Inputs:\n prices: ['high', 'low', 'close']\n Parameters:\n timeperiod: 14\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_671stream_WILLR = {"stream_WILLR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_671stream_WILLR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_670stream_WILLR}; -static PyObject *__pyx_pw_5talib_7_ta_lib_671stream_WILLR(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -93392,7 +80162,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_WILLR (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -93400,69 +80170,48 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 5287, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5287, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5287, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5287, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_high)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5185, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_low)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5185, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, 1); __PYX_ERR(4, 5185, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_close)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5185, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, 2); __PYX_ERR(4, 5185, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5185, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_WILLR") < 0)) __PYX_ERR(4, 5185, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 5287, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5287, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5287, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5287, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } @@ -93471,48 +80220,47 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5187, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5289, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 5185, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 5287, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5187, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5187, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5187, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_670stream_WILLR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5289, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5289, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5289, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_682stream_WILLR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_682stream_WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_high_data; @@ -93524,8 +80272,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp __pyx_t_3; + npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -93534,43 +80281,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject __Pyx_INCREF((PyObject *)__pyx_v_low); __Pyx_INCREF((PyObject *)__pyx_v_close); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5208, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5209, __pyx_L1_error) - __pyx_v_high_data = ((double *)__pyx_t_2); + __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5210, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5312, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5211, __pyx_L1_error) - __pyx_v_low_data = ((double *)__pyx_t_2); + __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5212, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5213, __pyx_L1_error) - __pyx_v_close_data = ((double *)__pyx_t_2); + __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_3 == ((npy_intp)-1))) __PYX_ERR(4, 5214, __pyx_L1_error) - __pyx_v_length = __pyx_t_3; + __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; __pyx_v_retCode = TA_WILLR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WILLR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5217, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WILLR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5218, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -93593,16 +80337,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject /* Python wrapper */ -static PyObject *__pyx_pw_5talib_7_ta_lib_673stream_WMA(PyObject *__pyx_self, +static PyObject *__pyx_pw_5talib_7_ta_lib_685stream_WMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_672stream_WMA, " WMA(real[, timeperiod=?])\n\n Weighted Moving Average (Overlap Studies)\n\n Inputs:\n real: (any ndarray)\n Parameters:\n timeperiod: 30\n Outputs:\n real\n "); -static PyMethodDef __pyx_mdef_5talib_7_ta_lib_673stream_WMA = {"stream_WMA", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_673stream_WMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_672stream_WMA}; -static PyObject *__pyx_pw_5talib_7_ta_lib_673stream_WMA(PyObject *__pyx_self, +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 PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else @@ -93623,7 +80367,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_WMA (wrapper)", 0); #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS + #if CYTHON_ASSUME_SAFE_SIZE __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; @@ -93631,89 +80375,81 @@ PyObject *__pyx_args, PyObject *__pyx_kwds #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; + 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 (__pyx_kwds_len > 0) { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5322, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5322, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_real)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5220, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeperiod); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(4, 5220, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stream_WMA") < 0)) __PYX_ERR(4, 5220, __pyx_L3_error) + const Py_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) + 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) } } } else { switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5322, __pyx_L3_error) CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5322, __pyx_L3_error) break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_real = ((PyArrayObject *)values[0]); if (values[1]) { - __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5222, __pyx_L3_error) + __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5324, __pyx_L3_error) } else { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("stream_WMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5220, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("stream_WMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5322, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } __Pyx_AddTraceback("talib._ta_lib.stream_WMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5222, __pyx_L1_error) - __pyx_r = __pyx_pf_5talib_7_ta_lib_672stream_WMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5324, __pyx_L1_error) + __pyx_r = __pyx_pf_5talib_7_ta_lib_684stream_WMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); } + __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { +static PyObject *__pyx_pf_5talib_7_ta_lib_684stream_WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) { npy_intp __pyx_v_length; TA_RetCode __pyx_v_retCode; double *__pyx_v_real_data; @@ -93723,35 +80459,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_WMA(CYTHON_UNUSED PyObject * PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - char *__pyx_t_2; - npy_intp *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_WMA", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); - __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5241, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real); if (unlikely(__pyx_t_2 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5242, __pyx_L1_error) - __pyx_v_real_data = ((double *)__pyx_t_2); + __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)); - __pyx_t_3 = __pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real); if (unlikely(__pyx_t_3 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(4, 5243, __pyx_L1_error) - __pyx_v_length = (__pyx_t_3[0]); + __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]); __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_retCode = TA_WMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5246, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5247, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -93769,2199 +80501,65 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_WMA(CYTHON_UNUSED PyObject * __Pyx_RefNannyFinishContext(); return __pyx_r; } +/* #### Code section: module_exttypes ### */ static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif -/* #### Code section: pystring_table ### */ - -static int __Pyx_CreateStringTabAndInitStrings(void) { - __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_s_3, __pyx_k_3, sizeof(__pyx_k_3), 0, 0, 1, 0}, - {&__pyx_n_s_ACOS, __pyx_k_ACOS, sizeof(__pyx_k_ACOS), 0, 0, 1, 1}, - {&__pyx_n_s_AD, __pyx_k_AD, sizeof(__pyx_k_AD), 0, 0, 1, 1}, - {&__pyx_n_s_ADD, __pyx_k_ADD, sizeof(__pyx_k_ADD), 0, 0, 1, 1}, - {&__pyx_n_s_ADOSC, __pyx_k_ADOSC, sizeof(__pyx_k_ADOSC), 0, 0, 1, 1}, - {&__pyx_n_s_ADX, __pyx_k_ADX, sizeof(__pyx_k_ADX), 0, 0, 1, 1}, - {&__pyx_n_s_ADXR, __pyx_k_ADXR, sizeof(__pyx_k_ADXR), 0, 0, 1, 1}, - {&__pyx_n_s_ALL, __pyx_k_ALL, sizeof(__pyx_k_ALL), 0, 0, 1, 1}, - {&__pyx_n_s_APO, __pyx_k_APO, sizeof(__pyx_k_APO), 0, 0, 1, 1}, - {&__pyx_n_s_AROON, __pyx_k_AROON, sizeof(__pyx_k_AROON), 0, 0, 1, 1}, - {&__pyx_n_s_AROONOSC, __pyx_k_AROONOSC, sizeof(__pyx_k_AROONOSC), 0, 0, 1, 1}, - {&__pyx_n_s_ARRAY_TYPES, __pyx_k_ARRAY_TYPES, sizeof(__pyx_k_ARRAY_TYPES), 0, 0, 1, 1}, - {&__pyx_n_s_ASIN, __pyx_k_ASIN, sizeof(__pyx_k_ASIN), 0, 0, 1, 1}, - {&__pyx_n_s_ATAN, __pyx_k_ATAN, sizeof(__pyx_k_ATAN), 0, 0, 1, 1}, - {&__pyx_n_s_ATR, __pyx_k_ATR, sizeof(__pyx_k_ATR), 0, 0, 1, 1}, - {&__pyx_n_s_AVGPRICE, __pyx_k_AVGPRICE, sizeof(__pyx_k_AVGPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_AllCandleSettings, __pyx_k_AllCandleSettings, sizeof(__pyx_k_AllCandleSettings), 0, 0, 1, 1}, - {&__pyx_kp_s_Allocation_Error_TA_ALLOC_ERR, __pyx_k_Allocation_Error_TA_ALLOC_ERR, sizeof(__pyx_k_Allocation_Error_TA_ALLOC_ERR), 0, 0, 1, 0}, - {&__pyx_n_s_BBANDS, __pyx_k_BBANDS, sizeof(__pyx_k_BBANDS), 0, 0, 1, 1}, - {&__pyx_n_s_BETA, __pyx_k_BETA, sizeof(__pyx_k_BETA), 0, 0, 1, 1}, - {&__pyx_n_s_BOP, __pyx_k_BOP, sizeof(__pyx_k_BOP), 0, 0, 1, 1}, - {&__pyx_kp_s_Bad_Object_TA_BAD_OBJECT, __pyx_k_Bad_Object_TA_BAD_OBJECT, sizeof(__pyx_k_Bad_Object_TA_BAD_OBJECT), 0, 0, 1, 0}, - {&__pyx_kp_s_Bad_Parameter_TA_BAD_PARAM, __pyx_k_Bad_Parameter_TA_BAD_PARAM, sizeof(__pyx_k_Bad_Parameter_TA_BAD_PARAM), 0, 0, 1, 0}, - {&__pyx_n_s_BodyDoji, __pyx_k_BodyDoji, sizeof(__pyx_k_BodyDoji), 0, 0, 1, 1}, - {&__pyx_n_s_BodyLong, __pyx_k_BodyLong, sizeof(__pyx_k_BodyLong), 0, 0, 1, 1}, - {&__pyx_n_s_BodyShort, __pyx_k_BodyShort, sizeof(__pyx_k_BodyShort), 0, 0, 1, 1}, - {&__pyx_n_s_BodyVeryLong, __pyx_k_BodyVeryLong, sizeof(__pyx_k_BodyVeryLong), 0, 0, 1, 1}, - {&__pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut, __pyx_k_Bull_Bear_Pattern_Bearish_0_Neut, sizeof(__pyx_k_Bull_Bear_Pattern_Bearish_0_Neut), 0, 0, 1, 0}, - {&__pyx_n_s_CCI, __pyx_k_CCI, sizeof(__pyx_k_CCI), 0, 0, 1, 1}, - {&__pyx_n_s_CDL2CROWS, __pyx_k_CDL2CROWS, sizeof(__pyx_k_CDL2CROWS), 0, 0, 1, 1}, - {&__pyx_n_s_CDL3BLACKCROWS, __pyx_k_CDL3BLACKCROWS, sizeof(__pyx_k_CDL3BLACKCROWS), 0, 0, 1, 1}, - {&__pyx_n_s_CDL3INSIDE, __pyx_k_CDL3INSIDE, sizeof(__pyx_k_CDL3INSIDE), 0, 0, 1, 1}, - {&__pyx_n_s_CDL3LINESTRIKE, __pyx_k_CDL3LINESTRIKE, sizeof(__pyx_k_CDL3LINESTRIKE), 0, 0, 1, 1}, - {&__pyx_n_s_CDL3OUTSIDE, __pyx_k_CDL3OUTSIDE, sizeof(__pyx_k_CDL3OUTSIDE), 0, 0, 1, 1}, - {&__pyx_n_s_CDL3STARSINSOUTH, __pyx_k_CDL3STARSINSOUTH, sizeof(__pyx_k_CDL3STARSINSOUTH), 0, 0, 1, 1}, - {&__pyx_n_s_CDL3WHITESOLDIERS, __pyx_k_CDL3WHITESOLDIERS, sizeof(__pyx_k_CDL3WHITESOLDIERS), 0, 0, 1, 1}, - {&__pyx_n_s_CDLABANDONEDBABY, __pyx_k_CDLABANDONEDBABY, sizeof(__pyx_k_CDLABANDONEDBABY), 0, 0, 1, 1}, - {&__pyx_n_s_CDLADVANCEBLOCK, __pyx_k_CDLADVANCEBLOCK, sizeof(__pyx_k_CDLADVANCEBLOCK), 0, 0, 1, 1}, - {&__pyx_n_s_CDLBELTHOLD, __pyx_k_CDLBELTHOLD, sizeof(__pyx_k_CDLBELTHOLD), 0, 0, 1, 1}, - {&__pyx_n_s_CDLBREAKAWAY, __pyx_k_CDLBREAKAWAY, sizeof(__pyx_k_CDLBREAKAWAY), 0, 0, 1, 1}, - {&__pyx_n_s_CDLCLOSINGMARUBOZU, __pyx_k_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_CDLCLOSINGMARUBOZU), 0, 0, 1, 1}, - {&__pyx_n_s_CDLCONCEALBABYSWALL, __pyx_k_CDLCONCEALBABYSWALL, sizeof(__pyx_k_CDLCONCEALBABYSWALL), 0, 0, 1, 1}, - {&__pyx_n_s_CDLCOUNTERATTACK, __pyx_k_CDLCOUNTERATTACK, sizeof(__pyx_k_CDLCOUNTERATTACK), 0, 0, 1, 1}, - {&__pyx_n_s_CDLDARKCLOUDCOVER, __pyx_k_CDLDARKCLOUDCOVER, sizeof(__pyx_k_CDLDARKCLOUDCOVER), 0, 0, 1, 1}, - {&__pyx_n_s_CDLDOJI, __pyx_k_CDLDOJI, sizeof(__pyx_k_CDLDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_CDLDOJISTAR, __pyx_k_CDLDOJISTAR, sizeof(__pyx_k_CDLDOJISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_CDLDRAGONFLYDOJI, __pyx_k_CDLDRAGONFLYDOJI, sizeof(__pyx_k_CDLDRAGONFLYDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_CDLENGULFING, __pyx_k_CDLENGULFING, sizeof(__pyx_k_CDLENGULFING), 0, 0, 1, 1}, - {&__pyx_n_s_CDLEVENINGDOJISTAR, __pyx_k_CDLEVENINGDOJISTAR, sizeof(__pyx_k_CDLEVENINGDOJISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_CDLEVENINGSTAR, __pyx_k_CDLEVENINGSTAR, sizeof(__pyx_k_CDLEVENINGSTAR), 0, 0, 1, 1}, - {&__pyx_n_s_CDLGAPSIDESIDEWHITE, __pyx_k_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_CDLGAPSIDESIDEWHITE), 0, 0, 1, 1}, - {&__pyx_n_s_CDLGRAVESTONEDOJI, __pyx_k_CDLGRAVESTONEDOJI, sizeof(__pyx_k_CDLGRAVESTONEDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_CDLHAMMER, __pyx_k_CDLHAMMER, sizeof(__pyx_k_CDLHAMMER), 0, 0, 1, 1}, - {&__pyx_n_s_CDLHANGINGMAN, __pyx_k_CDLHANGINGMAN, sizeof(__pyx_k_CDLHANGINGMAN), 0, 0, 1, 1}, - {&__pyx_n_s_CDLHARAMI, __pyx_k_CDLHARAMI, sizeof(__pyx_k_CDLHARAMI), 0, 0, 1, 1}, - {&__pyx_n_s_CDLHARAMICROSS, __pyx_k_CDLHARAMICROSS, sizeof(__pyx_k_CDLHARAMICROSS), 0, 0, 1, 1}, - {&__pyx_n_s_CDLHIGHWAVE, __pyx_k_CDLHIGHWAVE, sizeof(__pyx_k_CDLHIGHWAVE), 0, 0, 1, 1}, - {&__pyx_n_s_CDLHIKKAKE, __pyx_k_CDLHIKKAKE, sizeof(__pyx_k_CDLHIKKAKE), 0, 0, 1, 1}, - {&__pyx_n_s_CDLHIKKAKEMOD, __pyx_k_CDLHIKKAKEMOD, sizeof(__pyx_k_CDLHIKKAKEMOD), 0, 0, 1, 1}, - {&__pyx_n_s_CDLHOMINGPIGEON, __pyx_k_CDLHOMINGPIGEON, sizeof(__pyx_k_CDLHOMINGPIGEON), 0, 0, 1, 1}, - {&__pyx_n_s_CDLIDENTICAL3CROWS, __pyx_k_CDLIDENTICAL3CROWS, sizeof(__pyx_k_CDLIDENTICAL3CROWS), 0, 0, 1, 1}, - {&__pyx_n_s_CDLINNECK, __pyx_k_CDLINNECK, sizeof(__pyx_k_CDLINNECK), 0, 0, 1, 1}, - {&__pyx_n_s_CDLINVERTEDHAMMER, __pyx_k_CDLINVERTEDHAMMER, sizeof(__pyx_k_CDLINVERTEDHAMMER), 0, 0, 1, 1}, - {&__pyx_n_s_CDLKICKING, __pyx_k_CDLKICKING, sizeof(__pyx_k_CDLKICKING), 0, 0, 1, 1}, - {&__pyx_n_s_CDLKICKINGBYLENGTH, __pyx_k_CDLKICKINGBYLENGTH, sizeof(__pyx_k_CDLKICKINGBYLENGTH), 0, 0, 1, 1}, - {&__pyx_n_s_CDLLADDERBOTTOM, __pyx_k_CDLLADDERBOTTOM, sizeof(__pyx_k_CDLLADDERBOTTOM), 0, 0, 1, 1}, - {&__pyx_n_s_CDLLONGLEGGEDDOJI, __pyx_k_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_CDLLONGLEGGEDDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_CDLLONGLINE, __pyx_k_CDLLONGLINE, sizeof(__pyx_k_CDLLONGLINE), 0, 0, 1, 1}, - {&__pyx_n_s_CDLMARUBOZU, __pyx_k_CDLMARUBOZU, sizeof(__pyx_k_CDLMARUBOZU), 0, 0, 1, 1}, - {&__pyx_n_s_CDLMATCHINGLOW, __pyx_k_CDLMATCHINGLOW, sizeof(__pyx_k_CDLMATCHINGLOW), 0, 0, 1, 1}, - {&__pyx_n_s_CDLMATHOLD, __pyx_k_CDLMATHOLD, sizeof(__pyx_k_CDLMATHOLD), 0, 0, 1, 1}, - {&__pyx_n_s_CDLMORNINGDOJISTAR, __pyx_k_CDLMORNINGDOJISTAR, sizeof(__pyx_k_CDLMORNINGDOJISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_CDLMORNINGSTAR, __pyx_k_CDLMORNINGSTAR, sizeof(__pyx_k_CDLMORNINGSTAR), 0, 0, 1, 1}, - {&__pyx_n_s_CDLONNECK, __pyx_k_CDLONNECK, sizeof(__pyx_k_CDLONNECK), 0, 0, 1, 1}, - {&__pyx_n_s_CDLPIERCING, __pyx_k_CDLPIERCING, sizeof(__pyx_k_CDLPIERCING), 0, 0, 1, 1}, - {&__pyx_n_s_CDLRICKSHAWMAN, __pyx_k_CDLRICKSHAWMAN, sizeof(__pyx_k_CDLRICKSHAWMAN), 0, 0, 1, 1}, - {&__pyx_n_s_CDLRISEFALL3METHODS, __pyx_k_CDLRISEFALL3METHODS, sizeof(__pyx_k_CDLRISEFALL3METHODS), 0, 0, 1, 1}, - {&__pyx_n_s_CDLSEPARATINGLINES, __pyx_k_CDLSEPARATINGLINES, sizeof(__pyx_k_CDLSEPARATINGLINES), 0, 0, 1, 1}, - {&__pyx_n_s_CDLSHOOTINGSTAR, __pyx_k_CDLSHOOTINGSTAR, sizeof(__pyx_k_CDLSHOOTINGSTAR), 0, 0, 1, 1}, - {&__pyx_n_s_CDLSHORTLINE, __pyx_k_CDLSHORTLINE, sizeof(__pyx_k_CDLSHORTLINE), 0, 0, 1, 1}, - {&__pyx_n_s_CDLSPINNINGTOP, __pyx_k_CDLSPINNINGTOP, sizeof(__pyx_k_CDLSPINNINGTOP), 0, 0, 1, 1}, - {&__pyx_n_s_CDLSTALLEDPATTERN, __pyx_k_CDLSTALLEDPATTERN, sizeof(__pyx_k_CDLSTALLEDPATTERN), 0, 0, 1, 1}, - {&__pyx_n_s_CDLSTICKSANDWICH, __pyx_k_CDLSTICKSANDWICH, sizeof(__pyx_k_CDLSTICKSANDWICH), 0, 0, 1, 1}, - {&__pyx_n_s_CDLTAKURI, __pyx_k_CDLTAKURI, sizeof(__pyx_k_CDLTAKURI), 0, 0, 1, 1}, - {&__pyx_n_s_CDLTASUKIGAP, __pyx_k_CDLTASUKIGAP, sizeof(__pyx_k_CDLTASUKIGAP), 0, 0, 1, 1}, - {&__pyx_n_s_CDLTHRUSTING, __pyx_k_CDLTHRUSTING, sizeof(__pyx_k_CDLTHRUSTING), 0, 0, 1, 1}, - {&__pyx_n_s_CDLTRISTAR, __pyx_k_CDLTRISTAR, sizeof(__pyx_k_CDLTRISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_CDLUNIQUE3RIVER, __pyx_k_CDLUNIQUE3RIVER, sizeof(__pyx_k_CDLUNIQUE3RIVER), 0, 0, 1, 1}, - {&__pyx_n_s_CDLUPSIDEGAP2CROWS, __pyx_k_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_CDLUPSIDEGAP2CROWS), 0, 0, 1, 1}, - {&__pyx_n_s_CDLXSIDEGAP3METHODS, __pyx_k_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_CDLXSIDEGAP3METHODS), 0, 0, 1, 1}, - {&__pyx_n_s_CEIL, __pyx_k_CEIL, sizeof(__pyx_k_CEIL), 0, 0, 1, 1}, - {&__pyx_n_s_CMO, __pyx_k_CMO, sizeof(__pyx_k_CMO), 0, 0, 1, 1}, - {&__pyx_n_s_CORREL, __pyx_k_CORREL, sizeof(__pyx_k_CORREL), 0, 0, 1, 1}, - {&__pyx_n_s_COS, __pyx_k_COS, sizeof(__pyx_k_COS), 0, 0, 1, 1}, - {&__pyx_n_s_COSH, __pyx_k_COSH, sizeof(__pyx_k_COSH), 0, 0, 1, 1}, - {&__pyx_n_s_CandleSettingType, __pyx_k_CandleSettingType, sizeof(__pyx_k_CandleSettingType), 0, 0, 1, 1}, - {&__pyx_n_s_DEMA, __pyx_k_DEMA, sizeof(__pyx_k_DEMA), 0, 0, 1, 1}, - {&__pyx_n_s_DIV, __pyx_k_DIV, sizeof(__pyx_k_DIV), 0, 0, 1, 1}, - {&__pyx_n_s_DX, __pyx_k_DX, sizeof(__pyx_k_DX), 0, 0, 1, 1}, - {&__pyx_kp_s_Dashed_Line, __pyx_k_Dashed_Line, sizeof(__pyx_k_Dashed_Line), 0, 0, 1, 0}, - {&__pyx_n_s_DataFrame, __pyx_k_DataFrame, sizeof(__pyx_k_DataFrame), 0, 0, 1, 1}, - {&__pyx_n_s_Dot, __pyx_k_Dot, sizeof(__pyx_k_Dot), 0, 0, 1, 1}, - {&__pyx_kp_s_Dotted_Line, __pyx_k_Dotted_Line, sizeof(__pyx_k_Dotted_Line), 0, 0, 1, 0}, - {&__pyx_kp_s_Double_Exponential_Moving_Averag, __pyx_k_Double_Exponential_Moving_Averag, sizeof(__pyx_k_Double_Exponential_Moving_Averag), 0, 0, 1, 0}, - {&__pyx_n_s_EMA, __pyx_k_EMA, sizeof(__pyx_k_EMA), 0, 0, 1, 1}, - {&__pyx_n_s_EXP, __pyx_k_EXP, sizeof(__pyx_k_EXP), 0, 0, 1, 1}, - {&__pyx_n_s_Equal, __pyx_k_Equal, sizeof(__pyx_k_Equal), 0, 0, 1, 1}, - {&__pyx_kp_s_Exponential_Moving_Average, __pyx_k_Exponential_Moving_Average, sizeof(__pyx_k_Exponential_Moving_Average), 0, 0, 1, 0}, - {&__pyx_n_s_FLOOR, __pyx_k_FLOOR, sizeof(__pyx_k_FLOOR), 0, 0, 1, 1}, - {&__pyx_n_s_Far, __pyx_k_Far, sizeof(__pyx_k_Far), 0, 0, 1, 1}, - {&__pyx_n_s_Function, __pyx_k_Function, sizeof(__pyx_k_Function), 0, 0, 1, 1}, - {&__pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F, __pyx_k_Function_Not_Found_TA_FUNC_NOT_F, sizeof(__pyx_k_Function_Not_Found_TA_FUNC_NOT_F), 0, 0, 1, 0}, - {&__pyx_n_s_Function___call, __pyx_k_Function___call, sizeof(__pyx_k_Function___call), 0, 0, 1, 1}, - {&__pyx_n_s_Function___call_function, __pyx_k_Function___call_function, sizeof(__pyx_k_Function___call_function), 0, 0, 1, 1}, - {&__pyx_n_s_Function___check_opt_input_value, __pyx_k_Function___check_opt_input_value, sizeof(__pyx_k_Function___check_opt_input_value), 0, 0, 1, 1}, - {&__pyx_n_s_Function___get_opt_input_value, __pyx_k_Function___get_opt_input_value, sizeof(__pyx_k_Function___get_opt_input_value), 0, 0, 1, 1}, - {&__pyx_n_s_Function___init, __pyx_k_Function___init, sizeof(__pyx_k_Function___init), 0, 0, 1, 1}, - {&__pyx_n_s_Function___input_price_series_na, __pyx_k_Function___input_price_series_na, sizeof(__pyx_k_Function___input_price_series_na), 0, 0, 1, 1}, - {&__pyx_n_s_Function___local, __pyx_k_Function___local, sizeof(__pyx_k_Function___local), 0, 0, 1, 1}, - {&__pyx_n_s_Function___repr, __pyx_k_Function___repr, sizeof(__pyx_k_Function___repr), 0, 0, 1, 1}, - {&__pyx_n_s_Function___str, __pyx_k_Function___str, sizeof(__pyx_k_Function___str), 0, 0, 1, 1}, - {&__pyx_n_s_Function___unicode, __pyx_k_Function___unicode, sizeof(__pyx_k_Function___unicode), 0, 0, 1, 1}, - {&__pyx_n_s_Function__call_function, __pyx_k_Function__call_function, sizeof(__pyx_k_Function__call_function), 0, 0, 1, 1}, - {&__pyx_n_s_Function__check_opt_input_value, __pyx_k_Function__check_opt_input_value, sizeof(__pyx_k_Function__check_opt_input_value), 0, 0, 1, 1}, - {&__pyx_n_s_Function__get_opt_input_value, __pyx_k_Function__get_opt_input_value, sizeof(__pyx_k_Function__get_opt_input_value), 0, 0, 1, 1}, - {&__pyx_n_s_Function__input_price_series_na, __pyx_k_Function__input_price_series_na, sizeof(__pyx_k_Function__input_price_series_na), 0, 0, 1, 1}, - {&__pyx_n_s_Function__local, __pyx_k_Function__local, sizeof(__pyx_k_Function__local), 0, 0, 1, 1}, - {&__pyx_n_s_Function__localdata, __pyx_k_Function__localdata, sizeof(__pyx_k_Function__localdata), 0, 0, 1, 1}, - {&__pyx_n_s_Function__name, __pyx_k_Function__name, sizeof(__pyx_k_Function__name), 0, 0, 1, 1}, - {&__pyx_n_s_Function__namestr, __pyx_k_Function__namestr, sizeof(__pyx_k_Function__namestr), 0, 0, 1, 1}, - {&__pyx_n_s_Function_function_flags, __pyx_k_Function_function_flags, sizeof(__pyx_k_Function_function_flags), 0, 0, 1, 1}, - {&__pyx_n_s_Function_get_input_arrays, __pyx_k_Function_get_input_arrays, sizeof(__pyx_k_Function_get_input_arrays), 0, 0, 1, 1}, - {&__pyx_n_s_Function_get_input_names, __pyx_k_Function_get_input_names, sizeof(__pyx_k_Function_get_input_names), 0, 0, 1, 1}, - {&__pyx_n_s_Function_get_parameters, __pyx_k_Function_get_parameters, sizeof(__pyx_k_Function_get_parameters), 0, 0, 1, 1}, - {&__pyx_kp_s_Function_has_an_unstable_period, __pyx_k_Function_has_an_unstable_period, sizeof(__pyx_k_Function_has_an_unstable_period), 0, 0, 1, 0}, - {&__pyx_n_s_Function_info, __pyx_k_Function_info, sizeof(__pyx_k_Function_info), 0, 0, 1, 1}, - {&__pyx_n_s_Function_lookback, __pyx_k_Function_lookback, sizeof(__pyx_k_Function_lookback), 0, 0, 1, 1}, - {&__pyx_n_s_Function_output_flags, __pyx_k_Function_output_flags, sizeof(__pyx_k_Function_output_flags), 0, 0, 1, 1}, - {&__pyx_n_s_Function_output_names, __pyx_k_Function_output_names, sizeof(__pyx_k_Function_output_names), 0, 0, 1, 1}, - {&__pyx_n_s_Function_outputs, __pyx_k_Function_outputs, sizeof(__pyx_k_Function_outputs), 0, 0, 1, 1}, - {&__pyx_n_s_Function_run, __pyx_k_Function_run, sizeof(__pyx_k_Function_run), 0, 0, 1, 1}, - {&__pyx_n_s_Function_set_function_args, __pyx_k_Function_set_function_args, sizeof(__pyx_k_Function_set_function_args), 0, 0, 1, 1}, - {&__pyx_n_s_Function_set_input_arrays, __pyx_k_Function_set_input_arrays, sizeof(__pyx_k_Function_set_input_arrays), 0, 0, 1, 1}, - {&__pyx_n_s_Function_set_input_names, __pyx_k_Function_set_input_names, sizeof(__pyx_k_Function_set_input_names), 0, 0, 1, 1}, - {&__pyx_n_s_Function_set_parameters, __pyx_k_Function_set_parameters, sizeof(__pyx_k_Function_set_parameters), 0, 0, 1, 1}, - {&__pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU, __pyx_k_Group_Not_Found_TA_GROUP_NOT_FOU, sizeof(__pyx_k_Group_Not_Found_TA_GROUP_NOT_FOU), 0, 0, 1, 0}, - {&__pyx_n_s_HT_DCPERIOD, __pyx_k_HT_DCPERIOD, sizeof(__pyx_k_HT_DCPERIOD), 0, 0, 1, 1}, - {&__pyx_n_s_HT_DCPHASE, __pyx_k_HT_DCPHASE, sizeof(__pyx_k_HT_DCPHASE), 0, 0, 1, 1}, - {&__pyx_n_s_HT_PHASOR, __pyx_k_HT_PHASOR, sizeof(__pyx_k_HT_PHASOR), 0, 0, 1, 1}, - {&__pyx_n_s_HT_SINE, __pyx_k_HT_SINE, sizeof(__pyx_k_HT_SINE), 0, 0, 1, 1}, - {&__pyx_n_s_HT_TRENDLINE, __pyx_k_HT_TRENDLINE, sizeof(__pyx_k_HT_TRENDLINE), 0, 0, 1, 1}, - {&__pyx_n_s_HT_TRENDMODE, __pyx_k_HT_TRENDMODE, sizeof(__pyx_k_HT_TRENDMODE), 0, 0, 1, 1}, - {&__pyx_n_s_HighLow, __pyx_k_HighLow, sizeof(__pyx_k_HighLow), 0, 0, 1, 1}, - {&__pyx_n_s_Histogram, __pyx_k_Histogram, sizeof(__pyx_k_Histogram), 0, 0, 1, 1}, - {&__pyx_n_s_INPUT_ARRAYS_TYPES, __pyx_k_INPUT_ARRAYS_TYPES, sizeof(__pyx_k_INPUT_ARRAYS_TYPES), 0, 0, 1, 1}, - {&__pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS, __pyx_k_INPUT_PRICE_SERIES_DEFAULTS, sizeof(__pyx_k_INPUT_PRICE_SERIES_DEFAULTS), 0, 0, 1, 1}, - {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, - {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, - {&__pyx_kp_s_Input_Not_All_Initialized_TA_INP, __pyx_k_Input_Not_All_Initialized_TA_INP, sizeof(__pyx_k_Input_Not_All_Initialized_TA_INP), 0, 0, 1, 0}, - {&__pyx_kp_s_Inputs, __pyx_k_Inputs, sizeof(__pyx_k_Inputs), 0, 0, 1, 0}, - {&__pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR, __pyx_k_Internal_Error_TA_INTERNAL_ERROR, sizeof(__pyx_k_Internal_Error_TA_INTERNAL_ERROR), 0, 0, 1, 0}, - {&__pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE, __pyx_k_Invalid_Handle_TA_INVALID_HANDLE, sizeof(__pyx_k_Invalid_Handle_TA_INVALID_HANDLE), 0, 0, 1, 0}, - {&__pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS, __pyx_k_Invalid_List_Type_TA_INVALID_LIS, sizeof(__pyx_k_Invalid_List_Type_TA_INVALID_LIS), 0, 0, 1, 0}, - {&__pyx_kp_s_Invalid_Parameter_Function_TA_IN, __pyx_k_Invalid_Parameter_Function_TA_IN, sizeof(__pyx_k_Invalid_Parameter_Function_TA_IN), 0, 0, 1, 0}, - {&__pyx_kp_s_Invalid_Parameter_Holder_TA_INVA, __pyx_k_Invalid_Parameter_Holder_TA_INVA, sizeof(__pyx_k_Invalid_Parameter_Holder_TA_INVA), 0, 0, 1, 0}, - {&__pyx_kp_s_Invalid_Parameter_Holder_Type_TA, __pyx_k_Invalid_Parameter_Holder_Type_TA, sizeof(__pyx_k_Invalid_Parameter_Holder_Type_TA), 0, 0, 1, 0}, - {&__pyx_kp_s_Invalid_parameter_value_for_s_ex, __pyx_k_Invalid_parameter_value_for_s_ex, sizeof(__pyx_k_Invalid_parameter_value_for_s_ex), 0, 0, 1, 0}, - {&__pyx_n_s_KAMA, __pyx_k_KAMA, sizeof(__pyx_k_KAMA), 0, 0, 1, 1}, - {&__pyx_kp_s_Kaufman_Adaptive_Moving_Average, __pyx_k_Kaufman_Adaptive_Moving_Average, sizeof(__pyx_k_Kaufman_Adaptive_Moving_Average), 0, 0, 1, 0}, - {&__pyx_n_s_LINEARREG, __pyx_k_LINEARREG, sizeof(__pyx_k_LINEARREG), 0, 0, 1, 1}, - {&__pyx_n_s_LINEARREG_ANGLE, __pyx_k_LINEARREG_ANGLE, sizeof(__pyx_k_LINEARREG_ANGLE), 0, 0, 1, 1}, - {&__pyx_n_s_LINEARREG_INTERCEPT, __pyx_k_LINEARREG_INTERCEPT, sizeof(__pyx_k_LINEARREG_INTERCEPT), 0, 0, 1, 1}, - {&__pyx_n_s_LINEARREG_SLOPE, __pyx_k_LINEARREG_SLOPE, sizeof(__pyx_k_LINEARREG_SLOPE), 0, 0, 1, 1}, - {&__pyx_n_s_LN, __pyx_k_LN, sizeof(__pyx_k_LN), 0, 0, 1, 1}, - {&__pyx_n_s_LOG10, __pyx_k_LOG10, sizeof(__pyx_k_LOG10), 0, 0, 1, 1}, - {&__pyx_kp_s_Library_Not_Initialized_TA_LIB_N, __pyx_k_Library_Not_Initialized_TA_LIB_N, sizeof(__pyx_k_Library_Not_Initialized_TA_LIB_N), 0, 0, 1, 0}, - {&__pyx_n_s_Line, __pyx_k_Line, sizeof(__pyx_k_Line), 0, 0, 1, 1}, - {&__pyx_n_s_MA, __pyx_k_MA, sizeof(__pyx_k_MA), 0, 0, 1, 1}, - {&__pyx_n_s_MACD, __pyx_k_MACD, sizeof(__pyx_k_MACD), 0, 0, 1, 1}, - {&__pyx_n_s_MACDEXT, __pyx_k_MACDEXT, sizeof(__pyx_k_MACDEXT), 0, 0, 1, 1}, - {&__pyx_n_s_MACDFIX, __pyx_k_MACDFIX, sizeof(__pyx_k_MACDFIX), 0, 0, 1, 1}, - {&__pyx_n_s_MAMA, __pyx_k_MAMA, sizeof(__pyx_k_MAMA), 0, 0, 1, 1}, - {&__pyx_n_s_MAVP, __pyx_k_MAVP, sizeof(__pyx_k_MAVP), 0, 0, 1, 1}, - {&__pyx_n_s_MAX, __pyx_k_MAX, sizeof(__pyx_k_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_MAXINDEX, __pyx_k_MAXINDEX, sizeof(__pyx_k_MAXINDEX), 0, 0, 1, 1}, - {&__pyx_n_s_MA_Type, __pyx_k_MA_Type, sizeof(__pyx_k_MA_Type), 0, 0, 1, 1}, - {&__pyx_n_s_MA_Type___getitem, __pyx_k_MA_Type___getitem, sizeof(__pyx_k_MA_Type___getitem), 0, 0, 1, 1}, - {&__pyx_n_s_MA_Type___init, __pyx_k_MA_Type___init, sizeof(__pyx_k_MA_Type___init), 0, 0, 1, 1}, - {&__pyx_n_s_MEDPRICE, __pyx_k_MEDPRICE, sizeof(__pyx_k_MEDPRICE), 0, 0, 1, 1}, - {&__pyx_kp_s_MESA_Adaptive_Moving_Average, __pyx_k_MESA_Adaptive_Moving_Average, sizeof(__pyx_k_MESA_Adaptive_Moving_Average), 0, 0, 1, 0}, - {&__pyx_n_s_MFI, __pyx_k_MFI, sizeof(__pyx_k_MFI), 0, 0, 1, 1}, - {&__pyx_n_s_MIDPOINT, __pyx_k_MIDPOINT, sizeof(__pyx_k_MIDPOINT), 0, 0, 1, 1}, - {&__pyx_n_s_MIDPRICE, __pyx_k_MIDPRICE, sizeof(__pyx_k_MIDPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_MIN, __pyx_k_MIN, sizeof(__pyx_k_MIN), 0, 0, 1, 1}, - {&__pyx_n_s_MININDEX, __pyx_k_MININDEX, sizeof(__pyx_k_MININDEX), 0, 0, 1, 1}, - {&__pyx_n_s_MINMAX, __pyx_k_MINMAX, sizeof(__pyx_k_MINMAX), 0, 0, 1, 1}, - {&__pyx_n_s_MINMAXINDEX, __pyx_k_MINMAXINDEX, sizeof(__pyx_k_MINMAXINDEX), 0, 0, 1, 1}, - {&__pyx_n_s_MINUS_DI, __pyx_k_MINUS_DI, sizeof(__pyx_k_MINUS_DI), 0, 0, 1, 1}, - {&__pyx_n_s_MINUS_DM, __pyx_k_MINUS_DM, sizeof(__pyx_k_MINUS_DM), 0, 0, 1, 1}, - {&__pyx_n_s_MOM, __pyx_k_MOM, sizeof(__pyx_k_MOM), 0, 0, 1, 1}, - {&__pyx_n_s_MULT, __pyx_k_MULT, sizeof(__pyx_k_MULT), 0, 0, 1, 1}, - {&__pyx_n_s_NATR, __pyx_k_NATR, sizeof(__pyx_k_NATR), 0, 0, 1, 1}, - {&__pyx_n_s_NONE, __pyx_k_NONE, sizeof(__pyx_k_NONE), 0, 0, 1, 1}, - {&__pyx_n_s_Near, __pyx_k_Near, sizeof(__pyx_k_Near), 0, 0, 1, 1}, - {&__pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED, __pyx_k_Not_Supported_TA_NOT_SUPPORTED, sizeof(__pyx_k_Not_Supported_TA_NOT_SUPPORTED), 0, 0, 1, 0}, - {&__pyx_kp_s_Not_enough_price_arguments_expec, __pyx_k_Not_enough_price_arguments_expec, sizeof(__pyx_k_Not_enough_price_arguments_expec), 0, 0, 1, 0}, - {&__pyx_n_s_OBV, __pyx_k_OBV, sizeof(__pyx_k_OBV), 0, 0, 1, 1}, - {&__pyx_n_s_OrderedDict, __pyx_k_OrderedDict, sizeof(__pyx_k_OrderedDict), 0, 0, 1, 1}, - {&__pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF, __pyx_k_Out_of_Range_End_Index_TA_OUT_OF, sizeof(__pyx_k_Out_of_Range_End_Index_TA_OUT_OF), 0, 0, 1, 0}, - {&__pyx_kp_s_Out_of_Range_Start_Index_TA_OUT, __pyx_k_Out_of_Range_Start_Index_TA_OUT, sizeof(__pyx_k_Out_of_Range_Start_Index_TA_OUT), 0, 0, 1, 0}, - {&__pyx_kp_s_Output_Not_All_Initialized_TA_OU, __pyx_k_Output_Not_All_Initialized_TA_OU, sizeof(__pyx_k_Output_Not_All_Initialized_TA_OU), 0, 0, 1, 0}, - {&__pyx_kp_s_Output_can_be_negative, __pyx_k_Output_can_be_negative, sizeof(__pyx_k_Output_can_be_negative), 0, 0, 1, 0}, - {&__pyx_kp_s_Output_can_be_positive, __pyx_k_Output_can_be_positive, sizeof(__pyx_k_Output_can_be_positive), 0, 0, 1, 0}, - {&__pyx_kp_s_Output_can_be_zero, __pyx_k_Output_can_be_zero, sizeof(__pyx_k_Output_can_be_zero), 0, 0, 1, 0}, - {&__pyx_kp_s_Output_is_a_candlestick, __pyx_k_Output_is_a_candlestick, sizeof(__pyx_k_Output_is_a_candlestick), 0, 0, 1, 0}, - {&__pyx_kp_s_Output_is_over_volume, __pyx_k_Output_is_over_volume, sizeof(__pyx_k_Output_is_over_volume), 0, 0, 1, 0}, - {&__pyx_kp_s_Output_scale_same_as_input, __pyx_k_Output_scale_same_as_input, sizeof(__pyx_k_Output_scale_same_as_input), 0, 0, 1, 0}, - {&__pyx_kp_s_Outputs, __pyx_k_Outputs, sizeof(__pyx_k_Outputs), 0, 0, 1, 0}, - {&__pyx_n_s_PANDAS_DATAFRAME, __pyx_k_PANDAS_DATAFRAME, sizeof(__pyx_k_PANDAS_DATAFRAME), 0, 0, 1, 1}, - {&__pyx_n_s_PANDAS_SERIES, __pyx_k_PANDAS_SERIES, sizeof(__pyx_k_PANDAS_SERIES), 0, 0, 1, 1}, - {&__pyx_n_s_PLUS_DI, __pyx_k_PLUS_DI, sizeof(__pyx_k_PLUS_DI), 0, 0, 1, 1}, - {&__pyx_n_s_PLUS_DM, __pyx_k_PLUS_DM, sizeof(__pyx_k_PLUS_DM), 0, 0, 1, 1}, - {&__pyx_n_s_POLARS_DATAFRAME, __pyx_k_POLARS_DATAFRAME, sizeof(__pyx_k_POLARS_DATAFRAME), 0, 0, 1, 1}, - {&__pyx_n_s_POLARS_SERIES, __pyx_k_POLARS_SERIES, sizeof(__pyx_k_POLARS_SERIES), 0, 0, 1, 1}, - {&__pyx_n_s_PPO, __pyx_k_PPO, sizeof(__pyx_k_PPO), 0, 0, 1, 1}, - {&__pyx_kp_s_Parameters, __pyx_k_Parameters, sizeof(__pyx_k_Parameters), 0, 0, 1, 0}, - {&__pyx_kp_s_Pattern_Bool, __pyx_k_Pattern_Bool, sizeof(__pyx_k_Pattern_Bool), 0, 0, 1, 0}, - {&__pyx_n_s_ROC, __pyx_k_ROC, sizeof(__pyx_k_ROC), 0, 0, 1, 1}, - {&__pyx_n_s_ROCP, __pyx_k_ROCP, sizeof(__pyx_k_ROCP), 0, 0, 1, 1}, - {&__pyx_n_s_ROCR, __pyx_k_ROCR, sizeof(__pyx_k_ROCR), 0, 0, 1, 1}, - {&__pyx_n_s_ROCR100, __pyx_k_ROCR100, sizeof(__pyx_k_ROCR100), 0, 0, 1, 1}, - {&__pyx_n_s_RSI, __pyx_k_RSI, sizeof(__pyx_k_RSI), 0, 0, 1, 1}, - {&__pyx_n_s_RangeType, __pyx_k_RangeType, sizeof(__pyx_k_RangeType), 0, 0, 1, 1}, - {&__pyx_n_s_RealBody, __pyx_k_RealBody, sizeof(__pyx_k_RealBody), 0, 0, 1, 1}, - {&__pyx_n_s_SAR, __pyx_k_SAR, sizeof(__pyx_k_SAR), 0, 0, 1, 1}, - {&__pyx_n_s_SAREXT, __pyx_k_SAREXT, sizeof(__pyx_k_SAREXT), 0, 0, 1, 1}, - {&__pyx_n_s_SIN, __pyx_k_SIN, sizeof(__pyx_k_SIN), 0, 0, 1, 1}, - {&__pyx_n_s_SINH, __pyx_k_SINH, sizeof(__pyx_k_SINH), 0, 0, 1, 1}, - {&__pyx_n_s_SMA, __pyx_k_SMA, sizeof(__pyx_k_SMA), 0, 0, 1, 1}, - {&__pyx_n_s_SQRT, __pyx_k_SQRT, sizeof(__pyx_k_SQRT), 0, 0, 1, 1}, - {&__pyx_n_s_STDDEV, __pyx_k_STDDEV, sizeof(__pyx_k_STDDEV), 0, 0, 1, 1}, - {&__pyx_n_s_STOCH, __pyx_k_STOCH, sizeof(__pyx_k_STOCH), 0, 0, 1, 1}, - {&__pyx_n_s_STOCHF, __pyx_k_STOCHF, sizeof(__pyx_k_STOCHF), 0, 0, 1, 1}, - {&__pyx_n_s_STOCHRSI, __pyx_k_STOCHRSI, sizeof(__pyx_k_STOCHRSI), 0, 0, 1, 1}, - {&__pyx_n_s_SUB, __pyx_k_SUB, sizeof(__pyx_k_SUB), 0, 0, 1, 1}, - {&__pyx_n_s_SUM, __pyx_k_SUM, sizeof(__pyx_k_SUM), 0, 0, 1, 1}, - {&__pyx_n_s_Series, __pyx_k_Series, sizeof(__pyx_k_Series), 0, 0, 1, 1}, - {&__pyx_n_s_ShadowLong, __pyx_k_ShadowLong, sizeof(__pyx_k_ShadowLong), 0, 0, 1, 1}, - {&__pyx_n_s_ShadowShort, __pyx_k_ShadowShort, sizeof(__pyx_k_ShadowShort), 0, 0, 1, 1}, - {&__pyx_n_s_ShadowVeryLong, __pyx_k_ShadowVeryLong, sizeof(__pyx_k_ShadowVeryLong), 0, 0, 1, 1}, - {&__pyx_n_s_ShadowVeryShort, __pyx_k_ShadowVeryShort, sizeof(__pyx_k_ShadowVeryShort), 0, 0, 1, 1}, - {&__pyx_n_s_Shadows, __pyx_k_Shadows, sizeof(__pyx_k_Shadows), 0, 0, 1, 1}, - {&__pyx_kp_s_Simple_Moving_Average, __pyx_k_Simple_Moving_Average, sizeof(__pyx_k_Simple_Moving_Average), 0, 0, 1, 0}, - {&__pyx_kp_s_Strength_Pattern_200_100_Bearish, __pyx_k_Strength_Pattern_200_100_Bearish, sizeof(__pyx_k_Strength_Pattern_200_100_Bearish), 0, 0, 1, 0}, - {&__pyx_n_s_T3, __pyx_k_T3, sizeof(__pyx_k_T3), 0, 0, 1, 1}, - {&__pyx_n_s_TAN, __pyx_k_TAN, sizeof(__pyx_k_TAN), 0, 0, 1, 1}, - {&__pyx_n_s_TANH, __pyx_k_TANH, sizeof(__pyx_k_TANH), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ACOS, __pyx_k_TA_ACOS, sizeof(__pyx_k_TA_ACOS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_AD, __pyx_k_TA_AD, sizeof(__pyx_k_TA_AD), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ADD, __pyx_k_TA_ADD, sizeof(__pyx_k_TA_ADD), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ADOSC, __pyx_k_TA_ADOSC, sizeof(__pyx_k_TA_ADOSC), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ADX, __pyx_k_TA_ADX, sizeof(__pyx_k_TA_ADX), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ADXR, __pyx_k_TA_ADXR, sizeof(__pyx_k_TA_ADXR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_APO, __pyx_k_TA_APO, sizeof(__pyx_k_TA_APO), 0, 0, 1, 1}, - {&__pyx_n_s_TA_AROON, __pyx_k_TA_AROON, sizeof(__pyx_k_TA_AROON), 0, 0, 1, 1}, - {&__pyx_n_s_TA_AROONOSC, __pyx_k_TA_AROONOSC, sizeof(__pyx_k_TA_AROONOSC), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ASIN, __pyx_k_TA_ASIN, sizeof(__pyx_k_TA_ASIN), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ATAN, __pyx_k_TA_ATAN, sizeof(__pyx_k_TA_ATAN), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ATR, __pyx_k_TA_ATR, sizeof(__pyx_k_TA_ATR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_AVGPRICE, __pyx_k_TA_AVGPRICE, sizeof(__pyx_k_TA_AVGPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_BBANDS, __pyx_k_TA_BBANDS, sizeof(__pyx_k_TA_BBANDS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_BETA, __pyx_k_TA_BETA, sizeof(__pyx_k_TA_BETA), 0, 0, 1, 1}, - {&__pyx_n_s_TA_BOP, __pyx_k_TA_BOP, sizeof(__pyx_k_TA_BOP), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CCI, __pyx_k_TA_CCI, sizeof(__pyx_k_TA_CCI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDL2CROWS, __pyx_k_TA_CDL2CROWS, sizeof(__pyx_k_TA_CDL2CROWS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDL3BLACKCROWS, __pyx_k_TA_CDL3BLACKCROWS, sizeof(__pyx_k_TA_CDL3BLACKCROWS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDL3INSIDE, __pyx_k_TA_CDL3INSIDE, sizeof(__pyx_k_TA_CDL3INSIDE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDL3LINESTRIKE, __pyx_k_TA_CDL3LINESTRIKE, sizeof(__pyx_k_TA_CDL3LINESTRIKE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDL3OUTSIDE, __pyx_k_TA_CDL3OUTSIDE, sizeof(__pyx_k_TA_CDL3OUTSIDE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDL3STARSINSOUTH, __pyx_k_TA_CDL3STARSINSOUTH, sizeof(__pyx_k_TA_CDL3STARSINSOUTH), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDL3WHITESOLDIERS, __pyx_k_TA_CDL3WHITESOLDIERS, sizeof(__pyx_k_TA_CDL3WHITESOLDIERS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLABANDONEDBABY, __pyx_k_TA_CDLABANDONEDBABY, sizeof(__pyx_k_TA_CDLABANDONEDBABY), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLADVANCEBLOCK, __pyx_k_TA_CDLADVANCEBLOCK, sizeof(__pyx_k_TA_CDLADVANCEBLOCK), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLBELTHOLD, __pyx_k_TA_CDLBELTHOLD, sizeof(__pyx_k_TA_CDLBELTHOLD), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLBREAKAWAY, __pyx_k_TA_CDLBREAKAWAY, sizeof(__pyx_k_TA_CDLBREAKAWAY), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLCLOSINGMARUBOZU, __pyx_k_TA_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_TA_CDLCLOSINGMARUBOZU), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLCONCEALBABYSWALL, __pyx_k_TA_CDLCONCEALBABYSWALL, sizeof(__pyx_k_TA_CDLCONCEALBABYSWALL), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLCOUNTERATTACK, __pyx_k_TA_CDLCOUNTERATTACK, sizeof(__pyx_k_TA_CDLCOUNTERATTACK), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLDARKCLOUDCOVER, __pyx_k_TA_CDLDARKCLOUDCOVER, sizeof(__pyx_k_TA_CDLDARKCLOUDCOVER), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLDOJI, __pyx_k_TA_CDLDOJI, sizeof(__pyx_k_TA_CDLDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLDOJISTAR, __pyx_k_TA_CDLDOJISTAR, sizeof(__pyx_k_TA_CDLDOJISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLDRAGONFLYDOJI, __pyx_k_TA_CDLDRAGONFLYDOJI, sizeof(__pyx_k_TA_CDLDRAGONFLYDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLENGULFING, __pyx_k_TA_CDLENGULFING, sizeof(__pyx_k_TA_CDLENGULFING), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLEVENINGDOJISTAR, __pyx_k_TA_CDLEVENINGDOJISTAR, sizeof(__pyx_k_TA_CDLEVENINGDOJISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLEVENINGSTAR, __pyx_k_TA_CDLEVENINGSTAR, sizeof(__pyx_k_TA_CDLEVENINGSTAR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLGAPSIDESIDEWHITE, __pyx_k_TA_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_TA_CDLGAPSIDESIDEWHITE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLGRAVESTONEDOJI, __pyx_k_TA_CDLGRAVESTONEDOJI, sizeof(__pyx_k_TA_CDLGRAVESTONEDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLHAMMER, __pyx_k_TA_CDLHAMMER, sizeof(__pyx_k_TA_CDLHAMMER), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLHANGINGMAN, __pyx_k_TA_CDLHANGINGMAN, sizeof(__pyx_k_TA_CDLHANGINGMAN), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLHARAMI, __pyx_k_TA_CDLHARAMI, sizeof(__pyx_k_TA_CDLHARAMI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLHARAMICROSS, __pyx_k_TA_CDLHARAMICROSS, sizeof(__pyx_k_TA_CDLHARAMICROSS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLHIGHWAVE, __pyx_k_TA_CDLHIGHWAVE, sizeof(__pyx_k_TA_CDLHIGHWAVE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLHIKKAKE, __pyx_k_TA_CDLHIKKAKE, sizeof(__pyx_k_TA_CDLHIKKAKE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLHIKKAKEMOD, __pyx_k_TA_CDLHIKKAKEMOD, sizeof(__pyx_k_TA_CDLHIKKAKEMOD), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLHOMINGPIGEON, __pyx_k_TA_CDLHOMINGPIGEON, sizeof(__pyx_k_TA_CDLHOMINGPIGEON), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLIDENTICAL3CROWS, __pyx_k_TA_CDLIDENTICAL3CROWS, sizeof(__pyx_k_TA_CDLIDENTICAL3CROWS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLINNECK, __pyx_k_TA_CDLINNECK, sizeof(__pyx_k_TA_CDLINNECK), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLINVERTEDHAMMER, __pyx_k_TA_CDLINVERTEDHAMMER, sizeof(__pyx_k_TA_CDLINVERTEDHAMMER), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLKICKING, __pyx_k_TA_CDLKICKING, sizeof(__pyx_k_TA_CDLKICKING), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLKICKINGBYLENGTH, __pyx_k_TA_CDLKICKINGBYLENGTH, sizeof(__pyx_k_TA_CDLKICKINGBYLENGTH), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLLADDERBOTTOM, __pyx_k_TA_CDLLADDERBOTTOM, sizeof(__pyx_k_TA_CDLLADDERBOTTOM), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLLONGLEGGEDDOJI, __pyx_k_TA_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_TA_CDLLONGLEGGEDDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLLONGLINE, __pyx_k_TA_CDLLONGLINE, sizeof(__pyx_k_TA_CDLLONGLINE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLMARUBOZU, __pyx_k_TA_CDLMARUBOZU, sizeof(__pyx_k_TA_CDLMARUBOZU), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLMATCHINGLOW, __pyx_k_TA_CDLMATCHINGLOW, sizeof(__pyx_k_TA_CDLMATCHINGLOW), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLMATHOLD, __pyx_k_TA_CDLMATHOLD, sizeof(__pyx_k_TA_CDLMATHOLD), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLMORNINGDOJISTAR, __pyx_k_TA_CDLMORNINGDOJISTAR, sizeof(__pyx_k_TA_CDLMORNINGDOJISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLMORNINGSTAR, __pyx_k_TA_CDLMORNINGSTAR, sizeof(__pyx_k_TA_CDLMORNINGSTAR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLONNECK, __pyx_k_TA_CDLONNECK, sizeof(__pyx_k_TA_CDLONNECK), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLPIERCING, __pyx_k_TA_CDLPIERCING, sizeof(__pyx_k_TA_CDLPIERCING), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLRICKSHAWMAN, __pyx_k_TA_CDLRICKSHAWMAN, sizeof(__pyx_k_TA_CDLRICKSHAWMAN), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLRISEFALL3METHODS, __pyx_k_TA_CDLRISEFALL3METHODS, sizeof(__pyx_k_TA_CDLRISEFALL3METHODS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLSEPARATINGLINES, __pyx_k_TA_CDLSEPARATINGLINES, sizeof(__pyx_k_TA_CDLSEPARATINGLINES), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLSHOOTINGSTAR, __pyx_k_TA_CDLSHOOTINGSTAR, sizeof(__pyx_k_TA_CDLSHOOTINGSTAR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLSHORTLINE, __pyx_k_TA_CDLSHORTLINE, sizeof(__pyx_k_TA_CDLSHORTLINE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLSPINNINGTOP, __pyx_k_TA_CDLSPINNINGTOP, sizeof(__pyx_k_TA_CDLSPINNINGTOP), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLSTALLEDPATTERN, __pyx_k_TA_CDLSTALLEDPATTERN, sizeof(__pyx_k_TA_CDLSTALLEDPATTERN), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLSTICKSANDWICH, __pyx_k_TA_CDLSTICKSANDWICH, sizeof(__pyx_k_TA_CDLSTICKSANDWICH), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLTAKURI, __pyx_k_TA_CDLTAKURI, sizeof(__pyx_k_TA_CDLTAKURI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLTASUKIGAP, __pyx_k_TA_CDLTASUKIGAP, sizeof(__pyx_k_TA_CDLTASUKIGAP), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLTHRUSTING, __pyx_k_TA_CDLTHRUSTING, sizeof(__pyx_k_TA_CDLTHRUSTING), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLTRISTAR, __pyx_k_TA_CDLTRISTAR, sizeof(__pyx_k_TA_CDLTRISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLUNIQUE3RIVER, __pyx_k_TA_CDLUNIQUE3RIVER, sizeof(__pyx_k_TA_CDLUNIQUE3RIVER), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLUPSIDEGAP2CROWS, __pyx_k_TA_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_TA_CDLUPSIDEGAP2CROWS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CDLXSIDEGAP3METHODS, __pyx_k_TA_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_TA_CDLXSIDEGAP3METHODS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CEIL, __pyx_k_TA_CEIL, sizeof(__pyx_k_TA_CEIL), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CMO, __pyx_k_TA_CMO, sizeof(__pyx_k_TA_CMO), 0, 0, 1, 1}, - {&__pyx_n_s_TA_CORREL, __pyx_k_TA_CORREL, sizeof(__pyx_k_TA_CORREL), 0, 0, 1, 1}, - {&__pyx_n_s_TA_COS, __pyx_k_TA_COS, sizeof(__pyx_k_TA_COS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_COSH, __pyx_k_TA_COSH, sizeof(__pyx_k_TA_COSH), 0, 0, 1, 1}, - {&__pyx_n_s_TA_DEMA, __pyx_k_TA_DEMA, sizeof(__pyx_k_TA_DEMA), 0, 0, 1, 1}, - {&__pyx_n_s_TA_DIV, __pyx_k_TA_DIV, sizeof(__pyx_k_TA_DIV), 0, 0, 1, 1}, - {&__pyx_n_s_TA_DX, __pyx_k_TA_DX, sizeof(__pyx_k_TA_DX), 0, 0, 1, 1}, - {&__pyx_n_s_TA_EMA, __pyx_k_TA_EMA, sizeof(__pyx_k_TA_EMA), 0, 0, 1, 1}, - {&__pyx_n_s_TA_EXP, __pyx_k_TA_EXP, sizeof(__pyx_k_TA_EXP), 0, 0, 1, 1}, - {&__pyx_n_s_TA_FLOOR, __pyx_k_TA_FLOOR, sizeof(__pyx_k_TA_FLOOR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_FUNCTION_NAMES, __pyx_k_TA_FUNCTION_NAMES, sizeof(__pyx_k_TA_FUNCTION_NAMES), 0, 0, 1, 1}, - {&__pyx_n_s_TA_FUNC_FLAGS, __pyx_k_TA_FUNC_FLAGS, sizeof(__pyx_k_TA_FUNC_FLAGS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_FuncTableAlloc, __pyx_k_TA_FuncTableAlloc, sizeof(__pyx_k_TA_FuncTableAlloc), 0, 0, 1, 1}, - {&__pyx_n_s_TA_FuncTableFree, __pyx_k_TA_FuncTableFree, sizeof(__pyx_k_TA_FuncTableFree), 0, 0, 1, 1}, - {&__pyx_n_s_TA_GetFuncHandle, __pyx_k_TA_GetFuncHandle, sizeof(__pyx_k_TA_GetFuncHandle), 0, 0, 1, 1}, - {&__pyx_n_s_TA_GetFuncInfo, __pyx_k_TA_GetFuncInfo, sizeof(__pyx_k_TA_GetFuncInfo), 0, 0, 1, 1}, - {&__pyx_n_s_TA_GetInputParameterInfo, __pyx_k_TA_GetInputParameterInfo, sizeof(__pyx_k_TA_GetInputParameterInfo), 0, 0, 1, 1}, - {&__pyx_n_s_TA_GetLookback, __pyx_k_TA_GetLookback, sizeof(__pyx_k_TA_GetLookback), 0, 0, 1, 1}, - {&__pyx_n_s_TA_GetOptInputParameterInfo, __pyx_k_TA_GetOptInputParameterInfo, sizeof(__pyx_k_TA_GetOptInputParameterInfo), 0, 0, 1, 1}, - {&__pyx_n_s_TA_GetOutputParameterInfo, __pyx_k_TA_GetOutputParameterInfo, sizeof(__pyx_k_TA_GetOutputParameterInfo), 0, 0, 1, 1}, - {&__pyx_n_s_TA_GroupTableAlloc, __pyx_k_TA_GroupTableAlloc, sizeof(__pyx_k_TA_GroupTableAlloc), 0, 0, 1, 1}, - {&__pyx_n_s_TA_GroupTableFree, __pyx_k_TA_GroupTableFree, sizeof(__pyx_k_TA_GroupTableFree), 0, 0, 1, 1}, - {&__pyx_n_s_TA_HT_DCPERIOD, __pyx_k_TA_HT_DCPERIOD, sizeof(__pyx_k_TA_HT_DCPERIOD), 0, 0, 1, 1}, - {&__pyx_n_s_TA_HT_DCPHASE, __pyx_k_TA_HT_DCPHASE, sizeof(__pyx_k_TA_HT_DCPHASE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_HT_PHASOR, __pyx_k_TA_HT_PHASOR, sizeof(__pyx_k_TA_HT_PHASOR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_HT_SINE, __pyx_k_TA_HT_SINE, sizeof(__pyx_k_TA_HT_SINE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_HT_TRENDLINE, __pyx_k_TA_HT_TRENDLINE, sizeof(__pyx_k_TA_HT_TRENDLINE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_HT_TRENDMODE, __pyx_k_TA_HT_TRENDMODE, sizeof(__pyx_k_TA_HT_TRENDMODE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_INPUT_FLAGS, __pyx_k_TA_INPUT_FLAGS, sizeof(__pyx_k_TA_INPUT_FLAGS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_Initialize, __pyx_k_TA_Initialize, sizeof(__pyx_k_TA_Initialize), 0, 0, 1, 1}, - {&__pyx_n_s_TA_KAMA, __pyx_k_TA_KAMA, sizeof(__pyx_k_TA_KAMA), 0, 0, 1, 1}, - {&__pyx_n_s_TA_LINEARREG, __pyx_k_TA_LINEARREG, sizeof(__pyx_k_TA_LINEARREG), 0, 0, 1, 1}, - {&__pyx_n_s_TA_LINEARREG_ANGLE, __pyx_k_TA_LINEARREG_ANGLE, sizeof(__pyx_k_TA_LINEARREG_ANGLE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_LINEARREG_INTERCEPT, __pyx_k_TA_LINEARREG_INTERCEPT, sizeof(__pyx_k_TA_LINEARREG_INTERCEPT), 0, 0, 1, 1}, - {&__pyx_n_s_TA_LINEARREG_SLOPE, __pyx_k_TA_LINEARREG_SLOPE, sizeof(__pyx_k_TA_LINEARREG_SLOPE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_LN, __pyx_k_TA_LN, sizeof(__pyx_k_TA_LN), 0, 0, 1, 1}, - {&__pyx_n_s_TA_LOG10, __pyx_k_TA_LOG10, sizeof(__pyx_k_TA_LOG10), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MA, __pyx_k_TA_MA, sizeof(__pyx_k_TA_MA), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MACD, __pyx_k_TA_MACD, sizeof(__pyx_k_TA_MACD), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MACDEXT, __pyx_k_TA_MACDEXT, sizeof(__pyx_k_TA_MACDEXT), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MACDFIX, __pyx_k_TA_MACDFIX, sizeof(__pyx_k_TA_MACDFIX), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MAMA, __pyx_k_TA_MAMA, sizeof(__pyx_k_TA_MAMA), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MAVP, __pyx_k_TA_MAVP, sizeof(__pyx_k_TA_MAVP), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MAX, __pyx_k_TA_MAX, sizeof(__pyx_k_TA_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MAXINDEX, __pyx_k_TA_MAXINDEX, sizeof(__pyx_k_TA_MAXINDEX), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MEDPRICE, __pyx_k_TA_MEDPRICE, sizeof(__pyx_k_TA_MEDPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MFI, __pyx_k_TA_MFI, sizeof(__pyx_k_TA_MFI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MIDPOINT, __pyx_k_TA_MIDPOINT, sizeof(__pyx_k_TA_MIDPOINT), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MIDPRICE, __pyx_k_TA_MIDPRICE, sizeof(__pyx_k_TA_MIDPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MIN, __pyx_k_TA_MIN, sizeof(__pyx_k_TA_MIN), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MININDEX, __pyx_k_TA_MININDEX, sizeof(__pyx_k_TA_MININDEX), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MINMAX, __pyx_k_TA_MINMAX, sizeof(__pyx_k_TA_MINMAX), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MINMAXINDEX, __pyx_k_TA_MINMAXINDEX, sizeof(__pyx_k_TA_MINMAXINDEX), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MINUS_DI, __pyx_k_TA_MINUS_DI, sizeof(__pyx_k_TA_MINUS_DI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MINUS_DM, __pyx_k_TA_MINUS_DM, sizeof(__pyx_k_TA_MINUS_DM), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MOM, __pyx_k_TA_MOM, sizeof(__pyx_k_TA_MOM), 0, 0, 1, 1}, - {&__pyx_n_s_TA_MULT, __pyx_k_TA_MULT, sizeof(__pyx_k_TA_MULT), 0, 0, 1, 1}, - {&__pyx_n_s_TA_NATR, __pyx_k_TA_NATR, sizeof(__pyx_k_TA_NATR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_OBV, __pyx_k_TA_OBV, sizeof(__pyx_k_TA_OBV), 0, 0, 1, 1}, - {&__pyx_n_s_TA_OUTPUT_FLAGS, __pyx_k_TA_OUTPUT_FLAGS, sizeof(__pyx_k_TA_OUTPUT_FLAGS), 0, 0, 1, 1}, - {&__pyx_n_s_TA_PLUS_DI, __pyx_k_TA_PLUS_DI, sizeof(__pyx_k_TA_PLUS_DI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_PLUS_DM, __pyx_k_TA_PLUS_DM, sizeof(__pyx_k_TA_PLUS_DM), 0, 0, 1, 1}, - {&__pyx_n_s_TA_PPO, __pyx_k_TA_PPO, sizeof(__pyx_k_TA_PPO), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ParamHolderAlloc, __pyx_k_TA_ParamHolderAlloc, sizeof(__pyx_k_TA_ParamHolderAlloc), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ParamHolderFree, __pyx_k_TA_ParamHolderFree, sizeof(__pyx_k_TA_ParamHolderFree), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ROC, __pyx_k_TA_ROC, sizeof(__pyx_k_TA_ROC), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ROCP, __pyx_k_TA_ROCP, sizeof(__pyx_k_TA_ROCP), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ROCR, __pyx_k_TA_ROCR, sizeof(__pyx_k_TA_ROCR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ROCR100, __pyx_k_TA_ROCR100, sizeof(__pyx_k_TA_ROCR100), 0, 0, 1, 1}, - {&__pyx_n_s_TA_RSI, __pyx_k_TA_RSI, sizeof(__pyx_k_TA_RSI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_RestoreCandleDefaultSettings, __pyx_k_TA_RestoreCandleDefaultSettings, sizeof(__pyx_k_TA_RestoreCandleDefaultSettings), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SAR, __pyx_k_TA_SAR, sizeof(__pyx_k_TA_SAR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SAREXT, __pyx_k_TA_SAREXT, sizeof(__pyx_k_TA_SAREXT), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SIN, __pyx_k_TA_SIN, sizeof(__pyx_k_TA_SIN), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SINH, __pyx_k_TA_SINH, sizeof(__pyx_k_TA_SINH), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SMA, __pyx_k_TA_SMA, sizeof(__pyx_k_TA_SMA), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SQRT, __pyx_k_TA_SQRT, sizeof(__pyx_k_TA_SQRT), 0, 0, 1, 1}, - {&__pyx_n_s_TA_STDDEV, __pyx_k_TA_STDDEV, sizeof(__pyx_k_TA_STDDEV), 0, 0, 1, 1}, - {&__pyx_n_s_TA_STOCH, __pyx_k_TA_STOCH, sizeof(__pyx_k_TA_STOCH), 0, 0, 1, 1}, - {&__pyx_n_s_TA_STOCHF, __pyx_k_TA_STOCHF, sizeof(__pyx_k_TA_STOCHF), 0, 0, 1, 1}, - {&__pyx_n_s_TA_STOCHRSI, __pyx_k_TA_STOCHRSI, sizeof(__pyx_k_TA_STOCHRSI), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SUB, __pyx_k_TA_SUB, sizeof(__pyx_k_TA_SUB), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SUM, __pyx_k_TA_SUM, sizeof(__pyx_k_TA_SUM), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SetCandleSettings, __pyx_k_TA_SetCandleSettings, sizeof(__pyx_k_TA_SetCandleSettings), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SetCompatibility, __pyx_k_TA_SetCompatibility, sizeof(__pyx_k_TA_SetCompatibility), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SetOptInputParamInteger, __pyx_k_TA_SetOptInputParamInteger, sizeof(__pyx_k_TA_SetOptInputParamInteger), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SetOptInputParamReal, __pyx_k_TA_SetOptInputParamReal, sizeof(__pyx_k_TA_SetOptInputParamReal), 0, 0, 1, 1}, - {&__pyx_n_s_TA_SetUnstablePeriod, __pyx_k_TA_SetUnstablePeriod, sizeof(__pyx_k_TA_SetUnstablePeriod), 0, 0, 1, 1}, - {&__pyx_n_s_TA_Shutdown, __pyx_k_TA_Shutdown, sizeof(__pyx_k_TA_Shutdown), 0, 0, 1, 1}, - {&__pyx_n_s_TA_T3, __pyx_k_TA_T3, sizeof(__pyx_k_TA_T3), 0, 0, 1, 1}, - {&__pyx_n_s_TA_TAN, __pyx_k_TA_TAN, sizeof(__pyx_k_TA_TAN), 0, 0, 1, 1}, - {&__pyx_n_s_TA_TANH, __pyx_k_TA_TANH, sizeof(__pyx_k_TA_TANH), 0, 0, 1, 1}, - {&__pyx_n_s_TA_TEMA, __pyx_k_TA_TEMA, sizeof(__pyx_k_TA_TEMA), 0, 0, 1, 1}, - {&__pyx_n_s_TA_TRANGE, __pyx_k_TA_TRANGE, sizeof(__pyx_k_TA_TRANGE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_TRIMA, __pyx_k_TA_TRIMA, sizeof(__pyx_k_TA_TRIMA), 0, 0, 1, 1}, - {&__pyx_n_s_TA_TRIX, __pyx_k_TA_TRIX, sizeof(__pyx_k_TA_TRIX), 0, 0, 1, 1}, - {&__pyx_n_s_TA_TSF, __pyx_k_TA_TSF, sizeof(__pyx_k_TA_TSF), 0, 0, 1, 1}, - {&__pyx_n_s_TA_TYPPRICE, __pyx_k_TA_TYPPRICE, sizeof(__pyx_k_TA_TYPPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_ULTOSC, __pyx_k_TA_ULTOSC, sizeof(__pyx_k_TA_ULTOSC), 0, 0, 1, 1}, - {&__pyx_n_s_TA_VAR, __pyx_k_TA_VAR, sizeof(__pyx_k_TA_VAR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_WCLPRICE, __pyx_k_TA_WCLPRICE, sizeof(__pyx_k_TA_WCLPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_TA_WILLR, __pyx_k_TA_WILLR, sizeof(__pyx_k_TA_WILLR), 0, 0, 1, 1}, - {&__pyx_n_s_TA_WMA, __pyx_k_TA_WMA, sizeof(__pyx_k_TA_WMA), 0, 0, 1, 1}, - {&__pyx_n_s_TEMA, __pyx_k_TEMA, sizeof(__pyx_k_TEMA), 0, 0, 1, 1}, - {&__pyx_n_s_TRANGE, __pyx_k_TRANGE, sizeof(__pyx_k_TRANGE), 0, 0, 1, 1}, - {&__pyx_n_s_TRIMA, __pyx_k_TRIMA, sizeof(__pyx_k_TRIMA), 0, 0, 1, 1}, - {&__pyx_n_s_TRIX, __pyx_k_TRIX, sizeof(__pyx_k_TRIX), 0, 0, 1, 1}, - {&__pyx_n_s_TSF, __pyx_k_TSF, sizeof(__pyx_k_TSF), 0, 0, 1, 1}, - {&__pyx_n_s_TYPPRICE, __pyx_k_TYPPRICE, sizeof(__pyx_k_TYPPRICE), 0, 0, 1, 1}, - {&__pyx_kp_s_This_is_a_pythonic_wrapper_arou, __pyx_k_This_is_a_pythonic_wrapper_arou, sizeof(__pyx_k_This_is_a_pythonic_wrapper_arou), 0, 0, 1, 0}, - {&__pyx_kp_s_Too_many_price_arguments_expecte, __pyx_k_Too_many_price_arguments_expecte, sizeof(__pyx_k_Too_many_price_arguments_expecte), 0, 0, 1, 0}, - {&__pyx_kp_s_Triangular_Moving_Average, __pyx_k_Triangular_Moving_Average, sizeof(__pyx_k_Triangular_Moving_Average), 0, 0, 1, 0}, - {&__pyx_kp_s_Triple_Exponential_Moving_Averag, __pyx_k_Triple_Exponential_Moving_Averag, sizeof(__pyx_k_Triple_Exponential_Moving_Averag), 0, 0, 1, 0}, - {&__pyx_kp_s_Triple_Generalized_Double_Expone, __pyx_k_Triple_Generalized_Double_Expone, sizeof(__pyx_k_Triple_Generalized_Double_Expone), 0, 0, 1, 0}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_ULTOSC, __pyx_k_ULTOSC, sizeof(__pyx_k_ULTOSC), 0, 0, 1, 1}, - {&__pyx_kp_s_Unknown_Error, __pyx_k_Unknown_Error, sizeof(__pyx_k_Unknown_Error), 0, 0, 1, 0}, - {&__pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR, __pyx_k_Unknown_Error_TA_UNKNOWN_ERR, sizeof(__pyx_k_Unknown_Error_TA_UNKNOWN_ERR), 0, 0, 1, 0}, - {&__pyx_n_s_VAR, __pyx_k_VAR, sizeof(__pyx_k_VAR), 0, 0, 1, 1}, - {&__pyx_kp_s_Values_represent_a_lower_limit, __pyx_k_Values_represent_a_lower_limit, sizeof(__pyx_k_Values_represent_a_lower_limit), 0, 0, 1, 0}, - {&__pyx_kp_s_Values_represent_an_upper_limit, __pyx_k_Values_represent_an_upper_limit, sizeof(__pyx_k_Values_represent_an_upper_limit), 0, 0, 1, 0}, - {&__pyx_n_s_WCLPRICE, __pyx_k_WCLPRICE, sizeof(__pyx_k_WCLPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_WILLR, __pyx_k_WILLR, sizeof(__pyx_k_WILLR), 0, 0, 1, 1}, - {&__pyx_n_s_WMA, __pyx_k_WMA, sizeof(__pyx_k_WMA), 0, 0, 1, 1}, - {&__pyx_kp_s_Weighted_Moving_Average, __pyx_k_Weighted_Moving_Average, sizeof(__pyx_k_Weighted_Moving_Average), 0, 0, 1, 0}, - {&__pyx_kp_s__10, __pyx_k__10, sizeof(__pyx_k__10), 0, 0, 1, 0}, - {&__pyx_kp_s__11, __pyx_k__11, sizeof(__pyx_k__11), 0, 0, 1, 0}, - {&__pyx_kp_s__12, __pyx_k__12, sizeof(__pyx_k__12), 0, 0, 1, 0}, - {&__pyx_n_s__240, __pyx_k__240, sizeof(__pyx_k__240), 0, 0, 1, 1}, - {&__pyx_kp_u__43, __pyx_k__43, sizeof(__pyx_k__43), 0, 1, 0, 0}, - {&__pyx_n_s__503, __pyx_k__503, sizeof(__pyx_k__503), 0, 0, 1, 1}, - {&__pyx_kp_s__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 0, 1, 0}, - {&__pyx_kp_s__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 0, 1, 0}, - {&__pyx_kp_s__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 0, 1, 0}, - {&__pyx_n_s_acceleration, __pyx_k_acceleration, sizeof(__pyx_k_acceleration), 0, 0, 1, 1}, - {&__pyx_n_s_accelerationinitlong, __pyx_k_accelerationinitlong, sizeof(__pyx_k_accelerationinitlong), 0, 0, 1, 1}, - {&__pyx_n_s_accelerationinitshort, __pyx_k_accelerationinitshort, sizeof(__pyx_k_accelerationinitshort), 0, 0, 1, 1}, - {&__pyx_n_s_accelerationlong, __pyx_k_accelerationlong, sizeof(__pyx_k_accelerationlong), 0, 0, 1, 1}, - {&__pyx_n_s_accelerationmaxlong, __pyx_k_accelerationmaxlong, sizeof(__pyx_k_accelerationmaxlong), 0, 0, 1, 1}, - {&__pyx_n_s_accelerationmaxshort, __pyx_k_accelerationmaxshort, sizeof(__pyx_k_accelerationmaxshort), 0, 0, 1, 1}, - {&__pyx_n_s_accelerationshort, __pyx_k_accelerationshort, sizeof(__pyx_k_accelerationshort), 0, 0, 1, 1}, - {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, - {&__pyx_kp_s_any_ndarray, __pyx_k_any_ndarray, sizeof(__pyx_k_any_ndarray), 0, 0, 1, 0}, - {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, - {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1}, - {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, - {&__pyx_n_s_ascii, __pyx_k_ascii, sizeof(__pyx_k_ascii), 0, 0, 1, 1}, - {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1}, - {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, - {&__pyx_n_s_avgperiod, __pyx_k_avgperiod, sizeof(__pyx_k_avgperiod), 0, 0, 1, 1}, - {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1}, - {&__pyx_n_s_begidx, __pyx_k_begidx, sizeof(__pyx_k_begidx), 0, 0, 1, 1}, - {&__pyx_n_s_bytes2str, __pyx_k_bytes2str, sizeof(__pyx_k_bytes2str), 0, 0, 1, 1}, - {&__pyx_n_s_call, __pyx_k_call, sizeof(__pyx_k_call), 0, 0, 1, 1}, - {&__pyx_n_s_call_function, __pyx_k_call_function, sizeof(__pyx_k_call_function), 0, 0, 1, 1}, - {&__pyx_n_s_check_opt_input_value, __pyx_k_check_opt_input_value, sizeof(__pyx_k_check_opt_input_value), 0, 0, 1, 1}, - {&__pyx_n_s_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_clone, __pyx_k_clone, sizeof(__pyx_k_clone), 0, 0, 1, 1}, - {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, - {&__pyx_n_s_close_data, __pyx_k_close_data, sizeof(__pyx_k_close_data), 0, 0, 1, 1}, - {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, - {&__pyx_n_s_column_stack, __pyx_k_column_stack, sizeof(__pyx_k_column_stack), 0, 0, 1, 1}, - {&__pyx_n_s_columns, __pyx_k_columns, sizeof(__pyx_k_columns), 0, 0, 1, 1}, - {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, - {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, - {&__pyx_n_s_default_value, __pyx_k_default_value, sizeof(__pyx_k_default_value), 0, 0, 1, 1}, - {&__pyx_n_s_defaults, __pyx_k_defaults, sizeof(__pyx_k_defaults), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_n_s_display_name, __pyx_k_display_name, sizeof(__pyx_k_display_name), 0, 0, 1, 1}, - {&__pyx_kp_s_display_name_s_group_s, __pyx_k_display_name_s_group_s, sizeof(__pyx_k_display_name_s_group_s), 0, 0, 1, 0}, - {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, - {&__pyx_n_s_docs, __pyx_k_docs, sizeof(__pyx_k_docs), 0, 0, 1, 1}, - {&__pyx_n_s_documentation, __pyx_k_documentation, sizeof(__pyx_k_documentation), 0, 0, 1, 1}, - {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1}, - {&__pyx_n_s_endidx, __pyx_k_endidx, sizeof(__pyx_k_endidx), 0, 0, 1, 1}, - {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, - {&__pyx_n_s_factor, __pyx_k_factor, sizeof(__pyx_k_factor), 0, 0, 1, 1}, - {&__pyx_n_s_fastd_matype, __pyx_k_fastd_matype, sizeof(__pyx_k_fastd_matype), 0, 0, 1, 1}, - {&__pyx_n_s_fastd_period, __pyx_k_fastd_period, sizeof(__pyx_k_fastd_period), 0, 0, 1, 1}, - {&__pyx_n_s_fastk_period, __pyx_k_fastk_period, sizeof(__pyx_k_fastk_period), 0, 0, 1, 1}, - {&__pyx_n_s_fastlimit, __pyx_k_fastlimit, sizeof(__pyx_k_fastlimit), 0, 0, 1, 1}, - {&__pyx_n_s_fastmatype, __pyx_k_fastmatype, sizeof(__pyx_k_fastmatype), 0, 0, 1, 1}, - {&__pyx_n_s_fastperiod, __pyx_k_fastperiod, sizeof(__pyx_k_fastperiod), 0, 0, 1, 1}, - {&__pyx_n_s_flag, __pyx_k_flag, sizeof(__pyx_k_flag), 0, 0, 1, 1}, - {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, - {&__pyx_n_s_flags_lookup_dict, __pyx_k_flags_lookup_dict, sizeof(__pyx_k_flags_lookup_dict), 0, 0, 1, 1}, - {&__pyx_n_s_func_args, __pyx_k_func_args, sizeof(__pyx_k_func_args), 0, 0, 1, 1}, - {&__pyx_n_s_func_info, __pyx_k_func_info, sizeof(__pyx_k_func_info), 0, 0, 1, 1}, - {&__pyx_n_s_func_line, __pyx_k_func_line, sizeof(__pyx_k_func_line), 0, 0, 1, 1}, - {&__pyx_n_s_func_object, __pyx_k_func_object, sizeof(__pyx_k_func_object), 0, 0, 1, 1}, - {&__pyx_n_s_function_flags, __pyx_k_function_flags, sizeof(__pyx_k_function_flags), 0, 0, 1, 1}, - {&__pyx_n_s_function_name, __pyx_k_function_name, sizeof(__pyx_k_function_name), 0, 0, 1, 1}, - {&__pyx_n_s_functions, __pyx_k_functions, sizeof(__pyx_k_functions), 0, 0, 1, 1}, - {&__pyx_n_s_get_defaults_and_docs, __pyx_k_get_defaults_and_docs, sizeof(__pyx_k_get_defaults_and_docs), 0, 0, 1, 1}, - {&__pyx_n_s_get_flags, __pyx_k_get_flags, sizeof(__pyx_k_get_flags), 0, 0, 1, 1}, - {&__pyx_n_s_get_input_arrays, __pyx_k_get_input_arrays, sizeof(__pyx_k_get_input_arrays), 0, 0, 1, 1}, - {&__pyx_n_s_get_input_names, __pyx_k_get_input_names, sizeof(__pyx_k_get_input_names), 0, 0, 1, 1}, - {&__pyx_n_s_get_opt_input_value, __pyx_k_get_opt_input_value, sizeof(__pyx_k_get_opt_input_value), 0, 0, 1, 1}, - {&__pyx_n_s_get_parameters, __pyx_k_get_parameters, sizeof(__pyx_k_get_parameters), 0, 0, 1, 1}, - {&__pyx_n_s_getitem, __pyx_k_getitem, sizeof(__pyx_k_getitem), 0, 0, 1, 1}, - {&__pyx_n_s_group, __pyx_k_group, sizeof(__pyx_k_group), 0, 0, 1, 1}, - {&__pyx_n_s_groups, __pyx_k_groups, sizeof(__pyx_k_groups), 0, 0, 1, 1}, - {&__pyx_n_s_help, __pyx_k_help, sizeof(__pyx_k_help), 0, 0, 1, 1}, - {&__pyx_n_s_high, __pyx_k_high, sizeof(__pyx_k_high), 0, 0, 1, 1}, - {&__pyx_n_s_high_data, __pyx_k_high_data, sizeof(__pyx_k_high_data), 0, 0, 1, 1}, - {&__pyx_n_s_holder, __pyx_k_holder, sizeof(__pyx_k_holder), 0, 0, 1, 1}, - {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, - {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, - {&__pyx_n_s_idx, __pyx_k_idx, sizeof(__pyx_k_idx), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_in, __pyx_k_in, sizeof(__pyx_k_in), 0, 0, 1, 1}, - {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1}, - {&__pyx_n_s_info, __pyx_k_info, sizeof(__pyx_k_info), 0, 0, 1, 1}, - {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, - {&__pyx_n_s_init_subclass, __pyx_k_init_subclass, sizeof(__pyx_k_init_subclass), 0, 0, 1, 1}, - {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, - {&__pyx_kp_s_input_array_has_wrong_dimensions, __pyx_k_input_array_has_wrong_dimensions, sizeof(__pyx_k_input_array_has_wrong_dimensions), 0, 0, 1, 0}, - {&__pyx_kp_s_input_array_lengths_are_differen, __pyx_k_input_array_lengths_are_differen, sizeof(__pyx_k_input_array_lengths_are_differen), 0, 0, 1, 0}, - {&__pyx_kp_s_input_array_type_is_not_double, __pyx_k_input_array_type_is_not_double, sizeof(__pyx_k_input_array_type_is_not_double), 0, 0, 1, 0}, - {&__pyx_n_s_input_arrays, __pyx_k_input_arrays, sizeof(__pyx_k_input_arrays), 0, 0, 1, 1}, - {&__pyx_kp_s_input_arrays_2, __pyx_k_input_arrays_2, sizeof(__pyx_k_input_arrays_2), 0, 0, 1, 0}, - {&__pyx_kp_s_input_arrays_parameter_missing_r, __pyx_k_input_arrays_parameter_missing_r, sizeof(__pyx_k_input_arrays_parameter_missing_r), 0, 0, 1, 0}, - {&__pyx_n_s_input_name, __pyx_k_input_name, sizeof(__pyx_k_input_name), 0, 0, 1, 1}, - {&__pyx_n_s_input_names, __pyx_k_input_names, sizeof(__pyx_k_input_names), 0, 0, 1, 1}, - {&__pyx_n_s_input_price_series_names, __pyx_k_input_price_series_names, sizeof(__pyx_k_input_price_series_names), 0, 0, 1, 1}, - {&__pyx_n_s_input_price_series_names_2, __pyx_k_input_price_series_names_2, sizeof(__pyx_k_input_price_series_names_2), 0, 0, 1, 1}, - {&__pyx_n_s_integer, __pyx_k_integer, sizeof(__pyx_k_integer), 0, 0, 1, 1}, - {&__pyx_kp_s_integer_values_are_100_0_or_100, __pyx_k_integer_values_are_100_0_or_100, sizeof(__pyx_k_integer_values_are_100_0_or_100), 0, 0, 1, 0}, - {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, - {&__pyx_n_s_is_empty, __pyx_k_is_empty, sizeof(__pyx_k_is_empty), 0, 0, 1, 1}, - {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, - {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, - {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, - {&__pyx_n_s_keys, __pyx_k_keys, sizeof(__pyx_k_keys), 0, 0, 1, 1}, - {&__pyx_n_s_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 0, 1, 1}, - {&__pyx_n_s_length, __pyx_k_length, sizeof(__pyx_k_length), 0, 0, 1, 1}, - {&__pyx_n_s_local, __pyx_k_local, sizeof(__pyx_k_local), 0, 0, 1, 1}, - {&__pyx_n_s_local_2, __pyx_k_local_2, sizeof(__pyx_k_local_2), 0, 0, 1, 1}, - {&__pyx_n_s_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 0, 1, 1}, - {&__pyx_n_s_lookback, __pyx_k_lookback, sizeof(__pyx_k_lookback), 0, 0, 1, 1}, - {&__pyx_n_s_lookup, __pyx_k_lookup, sizeof(__pyx_k_lookup), 0, 0, 1, 1}, - {&__pyx_n_s_low, __pyx_k_low, sizeof(__pyx_k_low), 0, 0, 1, 1}, - {&__pyx_n_s_low_data, __pyx_k_low_data, sizeof(__pyx_k_low_data), 0, 0, 1, 1}, - {&__pyx_n_s_lower, __pyx_k_lower, sizeof(__pyx_k_lower), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_math, __pyx_k_math, sizeof(__pyx_k_math), 0, 0, 1, 1}, - {&__pyx_n_s_matype, __pyx_k_matype, sizeof(__pyx_k_matype), 0, 0, 1, 1}, - {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, - {&__pyx_n_s_max_int, __pyx_k_max_int, sizeof(__pyx_k_max_int), 0, 0, 1, 1}, - {&__pyx_n_s_maximum, __pyx_k_maximum, sizeof(__pyx_k_maximum), 0, 0, 1, 1}, - {&__pyx_n_s_maxperiod, __pyx_k_maxperiod, sizeof(__pyx_k_maxperiod), 0, 0, 1, 1}, - {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, - {&__pyx_n_s_min, __pyx_k_min, sizeof(__pyx_k_min), 0, 0, 1, 1}, - {&__pyx_n_s_min_int, __pyx_k_min_int, sizeof(__pyx_k_min_int), 0, 0, 1, 1}, - {&__pyx_n_s_minperiod, __pyx_k_minperiod, sizeof(__pyx_k_minperiod), 0, 0, 1, 1}, - {&__pyx_n_s_missing, __pyx_k_missing, sizeof(__pyx_k_missing), 0, 0, 1, 1}, - {&__pyx_n_s_missing_keys, __pyx_k_missing_keys, sizeof(__pyx_k_missing_keys), 0, 0, 1, 1}, - {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, - {&__pyx_n_s_mro_entries, __pyx_k_mro_entries, sizeof(__pyx_k_mro_entries), 0, 0, 1, 1}, - {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1}, - {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, - {&__pyx_n_s_nan, __pyx_k_nan, sizeof(__pyx_k_nan), 0, 0, 1, 1}, - {&__pyx_n_s_nbdev, __pyx_k_nbdev, sizeof(__pyx_k_nbdev), 0, 0, 1, 1}, - {&__pyx_n_s_nbdevdn, __pyx_k_nbdevdn, sizeof(__pyx_k_nbdevdn), 0, 0, 1, 1}, - {&__pyx_n_s_nbdevup, __pyx_k_nbdevup, sizeof(__pyx_k_nbdevup), 0, 0, 1, 1}, - {&__pyx_n_s_no_existing_input_arrays, __pyx_k_no_existing_input_arrays, sizeof(__pyx_k_no_existing_input_arrays), 0, 0, 1, 1}, - {&__pyx_n_s_num_inputs, __pyx_k_num_inputs, sizeof(__pyx_k_num_inputs), 0, 0, 1, 1}, - {&__pyx_n_s_num_opt_inputs, __pyx_k_num_opt_inputs, sizeof(__pyx_k_num_opt_inputs), 0, 0, 1, 1}, - {&__pyx_n_s_num_outputs, __pyx_k_num_outputs, sizeof(__pyx_k_num_outputs), 0, 0, 1, 1}, - {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, - {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, - {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, - {&__pyx_n_s_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1}, - {&__pyx_n_s_offsetonreverse, __pyx_k_offsetonreverse, sizeof(__pyx_k_offsetonreverse), 0, 0, 1, 1}, - {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1}, - {&__pyx_n_s_openInterest, __pyx_k_openInterest, sizeof(__pyx_k_openInterest), 0, 0, 1, 1}, - {&__pyx_n_s_open_data, __pyx_k_open_data, sizeof(__pyx_k_open_data), 0, 0, 1, 1}, - {&__pyx_n_s_optIn, __pyx_k_optIn, sizeof(__pyx_k_optIn), 0, 0, 1, 1}, - {&__pyx_n_s_opt_input, __pyx_k_opt_input, sizeof(__pyx_k_opt_input), 0, 0, 1, 1}, - {&__pyx_n_s_opt_input_values, __pyx_k_opt_input_values, sizeof(__pyx_k_opt_input_values), 0, 0, 1, 1}, - {&__pyx_n_s_opt_inputs, __pyx_k_opt_inputs, sizeof(__pyx_k_opt_inputs), 0, 0, 1, 1}, - {&__pyx_n_s_ordereddict, __pyx_k_ordereddict, sizeof(__pyx_k_ordereddict), 0, 0, 1, 1}, - {&__pyx_n_s_out, __pyx_k_out, sizeof(__pyx_k_out), 0, 0, 1, 1}, - {&__pyx_n_s_outaroondown, __pyx_k_outaroondown, sizeof(__pyx_k_outaroondown), 0, 0, 1, 1}, - {&__pyx_n_s_outaroonup, __pyx_k_outaroonup, sizeof(__pyx_k_outaroonup), 0, 0, 1, 1}, - {&__pyx_n_s_outbegidx, __pyx_k_outbegidx, sizeof(__pyx_k_outbegidx), 0, 0, 1, 1}, - {&__pyx_n_s_outfama, __pyx_k_outfama, sizeof(__pyx_k_outfama), 0, 0, 1, 1}, - {&__pyx_n_s_outfastd, __pyx_k_outfastd, sizeof(__pyx_k_outfastd), 0, 0, 1, 1}, - {&__pyx_n_s_outfastk, __pyx_k_outfastk, sizeof(__pyx_k_outfastk), 0, 0, 1, 1}, - {&__pyx_n_s_outinphase, __pyx_k_outinphase, sizeof(__pyx_k_outinphase), 0, 0, 1, 1}, - {&__pyx_n_s_outinteger, __pyx_k_outinteger, sizeof(__pyx_k_outinteger), 0, 0, 1, 1}, - {&__pyx_n_s_outinteger_data, __pyx_k_outinteger_data, sizeof(__pyx_k_outinteger_data), 0, 0, 1, 1}, - {&__pyx_n_s_outleadsine, __pyx_k_outleadsine, sizeof(__pyx_k_outleadsine), 0, 0, 1, 1}, - {&__pyx_n_s_outmacd, __pyx_k_outmacd, sizeof(__pyx_k_outmacd), 0, 0, 1, 1}, - {&__pyx_n_s_outmacdhist, __pyx_k_outmacdhist, sizeof(__pyx_k_outmacdhist), 0, 0, 1, 1}, - {&__pyx_n_s_outmacdsignal, __pyx_k_outmacdsignal, sizeof(__pyx_k_outmacdsignal), 0, 0, 1, 1}, - {&__pyx_n_s_outmama, __pyx_k_outmama, sizeof(__pyx_k_outmama), 0, 0, 1, 1}, - {&__pyx_n_s_outmax, __pyx_k_outmax, sizeof(__pyx_k_outmax), 0, 0, 1, 1}, - {&__pyx_n_s_outmaxidx, __pyx_k_outmaxidx, sizeof(__pyx_k_outmaxidx), 0, 0, 1, 1}, - {&__pyx_n_s_outmaxidx_data, __pyx_k_outmaxidx_data, sizeof(__pyx_k_outmaxidx_data), 0, 0, 1, 1}, - {&__pyx_n_s_outmin, __pyx_k_outmin, sizeof(__pyx_k_outmin), 0, 0, 1, 1}, - {&__pyx_n_s_outminidx, __pyx_k_outminidx, sizeof(__pyx_k_outminidx), 0, 0, 1, 1}, - {&__pyx_n_s_outminidx_data, __pyx_k_outminidx_data, sizeof(__pyx_k_outminidx_data), 0, 0, 1, 1}, - {&__pyx_n_s_outnbelement, __pyx_k_outnbelement, sizeof(__pyx_k_outnbelement), 0, 0, 1, 1}, - {&__pyx_n_s_output, __pyx_k_output, sizeof(__pyx_k_output), 0, 0, 1, 1}, - {&__pyx_n_s_output_flags, __pyx_k_output_flags, sizeof(__pyx_k_output_flags), 0, 0, 1, 1}, - {&__pyx_n_s_output_name, __pyx_k_output_name, sizeof(__pyx_k_output_name), 0, 0, 1, 1}, - {&__pyx_n_s_output_names, __pyx_k_output_names, sizeof(__pyx_k_output_names), 0, 0, 1, 1}, - {&__pyx_n_s_outputs, __pyx_k_outputs, sizeof(__pyx_k_outputs), 0, 0, 1, 1}, - {&__pyx_n_s_outputs_valid, __pyx_k_outputs_valid, sizeof(__pyx_k_outputs_valid), 0, 0, 1, 1}, - {&__pyx_n_s_outquadrature, __pyx_k_outquadrature, sizeof(__pyx_k_outquadrature), 0, 0, 1, 1}, - {&__pyx_n_s_outreal, __pyx_k_outreal, sizeof(__pyx_k_outreal), 0, 0, 1, 1}, - {&__pyx_n_s_outreallowerband, __pyx_k_outreallowerband, sizeof(__pyx_k_outreallowerband), 0, 0, 1, 1}, - {&__pyx_n_s_outrealmiddleband, __pyx_k_outrealmiddleband, sizeof(__pyx_k_outrealmiddleband), 0, 0, 1, 1}, - {&__pyx_n_s_outrealupperband, __pyx_k_outrealupperband, sizeof(__pyx_k_outrealupperband), 0, 0, 1, 1}, - {&__pyx_n_s_outsine, __pyx_k_outsine, sizeof(__pyx_k_outsine), 0, 0, 1, 1}, - {&__pyx_n_s_outslowd, __pyx_k_outslowd, sizeof(__pyx_k_outslowd), 0, 0, 1, 1}, - {&__pyx_n_s_outslowk, __pyx_k_outslowk, sizeof(__pyx_k_outslowk), 0, 0, 1, 1}, - {&__pyx_n_s_pandas, __pyx_k_pandas, sizeof(__pyx_k_pandas), 0, 0, 1, 1}, - {&__pyx_n_s_param, __pyx_k_param, sizeof(__pyx_k_param), 0, 0, 1, 1}, - {&__pyx_n_s_param_name, __pyx_k_param_name, sizeof(__pyx_k_param_name), 0, 0, 1, 1}, - {&__pyx_n_s_parameters, __pyx_k_parameters, sizeof(__pyx_k_parameters), 0, 0, 1, 1}, - {&__pyx_n_s_params, __pyx_k_params, sizeof(__pyx_k_params), 0, 0, 1, 1}, - {&__pyx_n_s_penetration, __pyx_k_penetration, sizeof(__pyx_k_penetration), 0, 0, 1, 1}, - {&__pyx_n_s_period, __pyx_k_period, sizeof(__pyx_k_period), 0, 0, 1, 1}, - {&__pyx_n_s_periods, __pyx_k_periods, sizeof(__pyx_k_periods), 0, 0, 1, 1}, - {&__pyx_n_s_periods_data, __pyx_k_periods_data, sizeof(__pyx_k_periods_data), 0, 0, 1, 1}, - {&__pyx_n_s_polars, __pyx_k_polars, sizeof(__pyx_k_polars), 0, 0, 1, 1}, - {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1}, - {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, - {&__pyx_n_s_price, __pyx_k_price, sizeof(__pyx_k_price), 0, 0, 1, 1}, - {&__pyx_n_s_price0, __pyx_k_price0, sizeof(__pyx_k_price0), 0, 0, 1, 1}, - {&__pyx_n_s_price1, __pyx_k_price1, sizeof(__pyx_k_price1), 0, 0, 1, 1}, - {&__pyx_n_s_price_series, __pyx_k_price_series, sizeof(__pyx_k_price_series), 0, 0, 1, 1}, - {&__pyx_n_s_price_series_name_values, __pyx_k_price_series_name_values, sizeof(__pyx_k_price_series_name_values), 0, 0, 1, 1}, - {&__pyx_n_s_prices, __pyx_k_prices, sizeof(__pyx_k_prices), 0, 0, 1, 1}, - {&__pyx_n_s_property, __pyx_k_property, sizeof(__pyx_k_property), 0, 0, 1, 1}, - {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, - {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_rangetype, __pyx_k_rangetype, sizeof(__pyx_k_rangetype), 0, 0, 1, 1}, - {&__pyx_n_s_real, __pyx_k_real, sizeof(__pyx_k_real), 0, 0, 1, 1}, - {&__pyx_n_s_real0, __pyx_k_real0, sizeof(__pyx_k_real0), 0, 0, 1, 1}, - {&__pyx_n_s_real0_data, __pyx_k_real0_data, sizeof(__pyx_k_real0_data), 0, 0, 1, 1}, - {&__pyx_n_s_real1, __pyx_k_real1, sizeof(__pyx_k_real1), 0, 0, 1, 1}, - {&__pyx_n_s_real1_data, __pyx_k_real1_data, sizeof(__pyx_k_real1_data), 0, 0, 1, 1}, - {&__pyx_n_s_real_data, __pyx_k_real_data, sizeof(__pyx_k_real_data), 0, 0, 1, 1}, - {&__pyx_n_s_replace, __pyx_k_replace, sizeof(__pyx_k_replace), 0, 0, 1, 1}, - {&__pyx_n_s_repr, __pyx_k_repr, sizeof(__pyx_k_repr), 0, 0, 1, 1}, - {&__pyx_n_s_results, __pyx_k_results, sizeof(__pyx_k_results), 0, 0, 1, 1}, - {&__pyx_n_s_ret, __pyx_k_ret, sizeof(__pyx_k_ret), 0, 0, 1, 1}, - {&__pyx_n_s_retCode, __pyx_k_retCode, sizeof(__pyx_k_retCode), 0, 0, 1, 1}, - {&__pyx_n_s_ret_code, __pyx_k_ret_code, sizeof(__pyx_k_ret_code), 0, 0, 1, 1}, - {&__pyx_n_s_run, __pyx_k_run, sizeof(__pyx_k_run), 0, 0, 1, 1}, - {&__pyx_n_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 1}, - {&__pyx_kp_s_s_2, __pyx_k_s_2, sizeof(__pyx_k_s_2), 0, 0, 1, 0}, - {&__pyx_kp_s_s_3, __pyx_k_s_3, sizeof(__pyx_k_s_3), 0, 0, 1, 0}, - {&__pyx_kp_s_s_4, __pyx_k_s_4, sizeof(__pyx_k_s_4), 0, 0, 1, 0}, - {&__pyx_kp_s_s_function_failed_with_error_co, __pyx_k_s_function_failed_with_error_co, sizeof(__pyx_k_s_function_failed_with_error_co), 0, 0, 1, 0}, - {&__pyx_kp_s_s_s, __pyx_k_s_s, sizeof(__pyx_k_s_s), 0, 0, 1, 0}, - {&__pyx_kp_s_s_s_2, __pyx_k_s_s_2, sizeof(__pyx_k_s_s_2), 0, 0, 1, 0}, - {&__pyx_n_s_schema, __pyx_k_schema, sizeof(__pyx_k_schema), 0, 0, 1, 1}, - {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, - {&__pyx_n_s_series, __pyx_k_series, sizeof(__pyx_k_series), 0, 0, 1, 1}, - {&__pyx_n_s_set_function_args, __pyx_k_set_function_args, sizeof(__pyx_k_set_function_args), 0, 0, 1, 1}, - {&__pyx_n_s_set_input_arrays, __pyx_k_set_input_arrays, sizeof(__pyx_k_set_input_arrays), 0, 0, 1, 1}, - {&__pyx_n_s_set_input_names, __pyx_k_set_input_names, sizeof(__pyx_k_set_input_names), 0, 0, 1, 1}, - {&__pyx_n_s_set_name, __pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 0, 1, 1}, - {&__pyx_n_s_set_parameters, __pyx_k_set_parameters, sizeof(__pyx_k_set_parameters), 0, 0, 1, 1}, - {&__pyx_n_s_settingtype, __pyx_k_settingtype, sizeof(__pyx_k_settingtype), 0, 0, 1, 1}, - {&__pyx_n_s_signalmatype, __pyx_k_signalmatype, sizeof(__pyx_k_signalmatype), 0, 0, 1, 1}, - {&__pyx_n_s_signalperiod, __pyx_k_signalperiod, sizeof(__pyx_k_signalperiod), 0, 0, 1, 1}, - {&__pyx_n_s_skip_first, __pyx_k_skip_first, sizeof(__pyx_k_skip_first), 0, 0, 1, 1}, - {&__pyx_n_s_slowd_matype, __pyx_k_slowd_matype, sizeof(__pyx_k_slowd_matype), 0, 0, 1, 1}, - {&__pyx_n_s_slowd_period, __pyx_k_slowd_period, sizeof(__pyx_k_slowd_period), 0, 0, 1, 1}, - {&__pyx_n_s_slowk_matype, __pyx_k_slowk_matype, sizeof(__pyx_k_slowk_matype), 0, 0, 1, 1}, - {&__pyx_n_s_slowk_period, __pyx_k_slowk_period, sizeof(__pyx_k_slowk_period), 0, 0, 1, 1}, - {&__pyx_n_s_slowlimit, __pyx_k_slowlimit, sizeof(__pyx_k_slowlimit), 0, 0, 1, 1}, - {&__pyx_n_s_slowmatype, __pyx_k_slowmatype, sizeof(__pyx_k_slowmatype), 0, 0, 1, 1}, - {&__pyx_n_s_slowperiod, __pyx_k_slowperiod, sizeof(__pyx_k_slowperiod), 0, 0, 1, 1}, - {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, - {&__pyx_n_s_startvalue, __pyx_k_startvalue, sizeof(__pyx_k_startvalue), 0, 0, 1, 1}, - {&__pyx_n_s_str, __pyx_k_str, sizeof(__pyx_k_str), 0, 0, 1, 1}, - {&__pyx_n_s_str2bytes, __pyx_k_str2bytes, sizeof(__pyx_k_str2bytes), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ACOS, __pyx_k_stream_ACOS, sizeof(__pyx_k_stream_ACOS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_AD, __pyx_k_stream_AD, sizeof(__pyx_k_stream_AD), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ADD, __pyx_k_stream_ADD, sizeof(__pyx_k_stream_ADD), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ADOSC, __pyx_k_stream_ADOSC, sizeof(__pyx_k_stream_ADOSC), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ADX, __pyx_k_stream_ADX, sizeof(__pyx_k_stream_ADX), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ADXR, __pyx_k_stream_ADXR, sizeof(__pyx_k_stream_ADXR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_APO, __pyx_k_stream_APO, sizeof(__pyx_k_stream_APO), 0, 0, 1, 1}, - {&__pyx_n_s_stream_AROON, __pyx_k_stream_AROON, sizeof(__pyx_k_stream_AROON), 0, 0, 1, 1}, - {&__pyx_n_s_stream_AROONOSC, __pyx_k_stream_AROONOSC, sizeof(__pyx_k_stream_AROONOSC), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ASIN, __pyx_k_stream_ASIN, sizeof(__pyx_k_stream_ASIN), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ATAN, __pyx_k_stream_ATAN, sizeof(__pyx_k_stream_ATAN), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ATR, __pyx_k_stream_ATR, sizeof(__pyx_k_stream_ATR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_AVGPRICE, __pyx_k_stream_AVGPRICE, sizeof(__pyx_k_stream_AVGPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_BBANDS, __pyx_k_stream_BBANDS, sizeof(__pyx_k_stream_BBANDS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_BETA, __pyx_k_stream_BETA, sizeof(__pyx_k_stream_BETA), 0, 0, 1, 1}, - {&__pyx_n_s_stream_BOP, __pyx_k_stream_BOP, sizeof(__pyx_k_stream_BOP), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CCI, __pyx_k_stream_CCI, sizeof(__pyx_k_stream_CCI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDL2CROWS, __pyx_k_stream_CDL2CROWS, sizeof(__pyx_k_stream_CDL2CROWS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDL3BLACKCROWS, __pyx_k_stream_CDL3BLACKCROWS, sizeof(__pyx_k_stream_CDL3BLACKCROWS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDL3INSIDE, __pyx_k_stream_CDL3INSIDE, sizeof(__pyx_k_stream_CDL3INSIDE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDL3LINESTRIKE, __pyx_k_stream_CDL3LINESTRIKE, sizeof(__pyx_k_stream_CDL3LINESTRIKE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDL3OUTSIDE, __pyx_k_stream_CDL3OUTSIDE, sizeof(__pyx_k_stream_CDL3OUTSIDE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDL3STARSINSOUTH, __pyx_k_stream_CDL3STARSINSOUTH, sizeof(__pyx_k_stream_CDL3STARSINSOUTH), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDL3WHITESOLDIERS, __pyx_k_stream_CDL3WHITESOLDIERS, sizeof(__pyx_k_stream_CDL3WHITESOLDIERS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLABANDONEDBABY, __pyx_k_stream_CDLABANDONEDBABY, sizeof(__pyx_k_stream_CDLABANDONEDBABY), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLADVANCEBLOCK, __pyx_k_stream_CDLADVANCEBLOCK, sizeof(__pyx_k_stream_CDLADVANCEBLOCK), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLBELTHOLD, __pyx_k_stream_CDLBELTHOLD, sizeof(__pyx_k_stream_CDLBELTHOLD), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLBREAKAWAY, __pyx_k_stream_CDLBREAKAWAY, sizeof(__pyx_k_stream_CDLBREAKAWAY), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLCLOSINGMARUBOZU, __pyx_k_stream_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_stream_CDLCLOSINGMARUBOZU), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLCONCEALBABYSWALL, __pyx_k_stream_CDLCONCEALBABYSWALL, sizeof(__pyx_k_stream_CDLCONCEALBABYSWALL), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLCOUNTERATTACK, __pyx_k_stream_CDLCOUNTERATTACK, sizeof(__pyx_k_stream_CDLCOUNTERATTACK), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLDARKCLOUDCOVER, __pyx_k_stream_CDLDARKCLOUDCOVER, sizeof(__pyx_k_stream_CDLDARKCLOUDCOVER), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLDOJI, __pyx_k_stream_CDLDOJI, sizeof(__pyx_k_stream_CDLDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLDOJISTAR, __pyx_k_stream_CDLDOJISTAR, sizeof(__pyx_k_stream_CDLDOJISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLDRAGONFLYDOJI, __pyx_k_stream_CDLDRAGONFLYDOJI, sizeof(__pyx_k_stream_CDLDRAGONFLYDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLENGULFING, __pyx_k_stream_CDLENGULFING, sizeof(__pyx_k_stream_CDLENGULFING), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLEVENINGDOJISTAR, __pyx_k_stream_CDLEVENINGDOJISTAR, sizeof(__pyx_k_stream_CDLEVENINGDOJISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLEVENINGSTAR, __pyx_k_stream_CDLEVENINGSTAR, sizeof(__pyx_k_stream_CDLEVENINGSTAR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLGAPSIDESIDEWHITE, __pyx_k_stream_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_stream_CDLGAPSIDESIDEWHITE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLGRAVESTONEDOJI, __pyx_k_stream_CDLGRAVESTONEDOJI, sizeof(__pyx_k_stream_CDLGRAVESTONEDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLHAMMER, __pyx_k_stream_CDLHAMMER, sizeof(__pyx_k_stream_CDLHAMMER), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLHANGINGMAN, __pyx_k_stream_CDLHANGINGMAN, sizeof(__pyx_k_stream_CDLHANGINGMAN), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLHARAMI, __pyx_k_stream_CDLHARAMI, sizeof(__pyx_k_stream_CDLHARAMI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLHARAMICROSS, __pyx_k_stream_CDLHARAMICROSS, sizeof(__pyx_k_stream_CDLHARAMICROSS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLHIGHWAVE, __pyx_k_stream_CDLHIGHWAVE, sizeof(__pyx_k_stream_CDLHIGHWAVE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLHIKKAKE, __pyx_k_stream_CDLHIKKAKE, sizeof(__pyx_k_stream_CDLHIKKAKE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLHIKKAKEMOD, __pyx_k_stream_CDLHIKKAKEMOD, sizeof(__pyx_k_stream_CDLHIKKAKEMOD), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLHOMINGPIGEON, __pyx_k_stream_CDLHOMINGPIGEON, sizeof(__pyx_k_stream_CDLHOMINGPIGEON), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLIDENTICAL3CROWS, __pyx_k_stream_CDLIDENTICAL3CROWS, sizeof(__pyx_k_stream_CDLIDENTICAL3CROWS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLINNECK, __pyx_k_stream_CDLINNECK, sizeof(__pyx_k_stream_CDLINNECK), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLINVERTEDHAMMER, __pyx_k_stream_CDLINVERTEDHAMMER, sizeof(__pyx_k_stream_CDLINVERTEDHAMMER), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLKICKING, __pyx_k_stream_CDLKICKING, sizeof(__pyx_k_stream_CDLKICKING), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLKICKINGBYLENGTH, __pyx_k_stream_CDLKICKINGBYLENGTH, sizeof(__pyx_k_stream_CDLKICKINGBYLENGTH), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLLADDERBOTTOM, __pyx_k_stream_CDLLADDERBOTTOM, sizeof(__pyx_k_stream_CDLLADDERBOTTOM), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLLONGLEGGEDDOJI, __pyx_k_stream_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_stream_CDLLONGLEGGEDDOJI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLLONGLINE, __pyx_k_stream_CDLLONGLINE, sizeof(__pyx_k_stream_CDLLONGLINE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLMARUBOZU, __pyx_k_stream_CDLMARUBOZU, sizeof(__pyx_k_stream_CDLMARUBOZU), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLMATCHINGLOW, __pyx_k_stream_CDLMATCHINGLOW, sizeof(__pyx_k_stream_CDLMATCHINGLOW), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLMATHOLD, __pyx_k_stream_CDLMATHOLD, sizeof(__pyx_k_stream_CDLMATHOLD), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLMORNINGDOJISTAR, __pyx_k_stream_CDLMORNINGDOJISTAR, sizeof(__pyx_k_stream_CDLMORNINGDOJISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLMORNINGSTAR, __pyx_k_stream_CDLMORNINGSTAR, sizeof(__pyx_k_stream_CDLMORNINGSTAR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLONNECK, __pyx_k_stream_CDLONNECK, sizeof(__pyx_k_stream_CDLONNECK), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLPIERCING, __pyx_k_stream_CDLPIERCING, sizeof(__pyx_k_stream_CDLPIERCING), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLRICKSHAWMAN, __pyx_k_stream_CDLRICKSHAWMAN, sizeof(__pyx_k_stream_CDLRICKSHAWMAN), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLRISEFALL3METHODS, __pyx_k_stream_CDLRISEFALL3METHODS, sizeof(__pyx_k_stream_CDLRISEFALL3METHODS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLSEPARATINGLINES, __pyx_k_stream_CDLSEPARATINGLINES, sizeof(__pyx_k_stream_CDLSEPARATINGLINES), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLSHOOTINGSTAR, __pyx_k_stream_CDLSHOOTINGSTAR, sizeof(__pyx_k_stream_CDLSHOOTINGSTAR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLSHORTLINE, __pyx_k_stream_CDLSHORTLINE, sizeof(__pyx_k_stream_CDLSHORTLINE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLSPINNINGTOP, __pyx_k_stream_CDLSPINNINGTOP, sizeof(__pyx_k_stream_CDLSPINNINGTOP), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLSTALLEDPATTERN, __pyx_k_stream_CDLSTALLEDPATTERN, sizeof(__pyx_k_stream_CDLSTALLEDPATTERN), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLSTICKSANDWICH, __pyx_k_stream_CDLSTICKSANDWICH, sizeof(__pyx_k_stream_CDLSTICKSANDWICH), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLTAKURI, __pyx_k_stream_CDLTAKURI, sizeof(__pyx_k_stream_CDLTAKURI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLTASUKIGAP, __pyx_k_stream_CDLTASUKIGAP, sizeof(__pyx_k_stream_CDLTASUKIGAP), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLTHRUSTING, __pyx_k_stream_CDLTHRUSTING, sizeof(__pyx_k_stream_CDLTHRUSTING), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLTRISTAR, __pyx_k_stream_CDLTRISTAR, sizeof(__pyx_k_stream_CDLTRISTAR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLUNIQUE3RIVER, __pyx_k_stream_CDLUNIQUE3RIVER, sizeof(__pyx_k_stream_CDLUNIQUE3RIVER), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLUPSIDEGAP2CROWS, __pyx_k_stream_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_stream_CDLUPSIDEGAP2CROWS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CDLXSIDEGAP3METHODS, __pyx_k_stream_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_stream_CDLXSIDEGAP3METHODS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CEIL, __pyx_k_stream_CEIL, sizeof(__pyx_k_stream_CEIL), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CMO, __pyx_k_stream_CMO, sizeof(__pyx_k_stream_CMO), 0, 0, 1, 1}, - {&__pyx_n_s_stream_CORREL, __pyx_k_stream_CORREL, sizeof(__pyx_k_stream_CORREL), 0, 0, 1, 1}, - {&__pyx_n_s_stream_COS, __pyx_k_stream_COS, sizeof(__pyx_k_stream_COS), 0, 0, 1, 1}, - {&__pyx_n_s_stream_COSH, __pyx_k_stream_COSH, sizeof(__pyx_k_stream_COSH), 0, 0, 1, 1}, - {&__pyx_n_s_stream_DEMA, __pyx_k_stream_DEMA, sizeof(__pyx_k_stream_DEMA), 0, 0, 1, 1}, - {&__pyx_n_s_stream_DIV, __pyx_k_stream_DIV, sizeof(__pyx_k_stream_DIV), 0, 0, 1, 1}, - {&__pyx_n_s_stream_DX, __pyx_k_stream_DX, sizeof(__pyx_k_stream_DX), 0, 0, 1, 1}, - {&__pyx_n_s_stream_EMA, __pyx_k_stream_EMA, sizeof(__pyx_k_stream_EMA), 0, 0, 1, 1}, - {&__pyx_n_s_stream_EXP, __pyx_k_stream_EXP, sizeof(__pyx_k_stream_EXP), 0, 0, 1, 1}, - {&__pyx_n_s_stream_FLOOR, __pyx_k_stream_FLOOR, sizeof(__pyx_k_stream_FLOOR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_HT_DCPERIOD, __pyx_k_stream_HT_DCPERIOD, sizeof(__pyx_k_stream_HT_DCPERIOD), 0, 0, 1, 1}, - {&__pyx_n_s_stream_HT_DCPHASE, __pyx_k_stream_HT_DCPHASE, sizeof(__pyx_k_stream_HT_DCPHASE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_HT_PHASOR, __pyx_k_stream_HT_PHASOR, sizeof(__pyx_k_stream_HT_PHASOR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_HT_SINE, __pyx_k_stream_HT_SINE, sizeof(__pyx_k_stream_HT_SINE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_HT_TRENDLINE, __pyx_k_stream_HT_TRENDLINE, sizeof(__pyx_k_stream_HT_TRENDLINE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_HT_TRENDMODE, __pyx_k_stream_HT_TRENDMODE, sizeof(__pyx_k_stream_HT_TRENDMODE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_KAMA, __pyx_k_stream_KAMA, sizeof(__pyx_k_stream_KAMA), 0, 0, 1, 1}, - {&__pyx_n_s_stream_LINEARREG, __pyx_k_stream_LINEARREG, sizeof(__pyx_k_stream_LINEARREG), 0, 0, 1, 1}, - {&__pyx_n_s_stream_LINEARREG_ANGLE, __pyx_k_stream_LINEARREG_ANGLE, sizeof(__pyx_k_stream_LINEARREG_ANGLE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_LINEARREG_INTERCEPT, __pyx_k_stream_LINEARREG_INTERCEPT, sizeof(__pyx_k_stream_LINEARREG_INTERCEPT), 0, 0, 1, 1}, - {&__pyx_n_s_stream_LINEARREG_SLOPE, __pyx_k_stream_LINEARREG_SLOPE, sizeof(__pyx_k_stream_LINEARREG_SLOPE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_LN, __pyx_k_stream_LN, sizeof(__pyx_k_stream_LN), 0, 0, 1, 1}, - {&__pyx_n_s_stream_LOG10, __pyx_k_stream_LOG10, sizeof(__pyx_k_stream_LOG10), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MA, __pyx_k_stream_MA, sizeof(__pyx_k_stream_MA), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MACD, __pyx_k_stream_MACD, sizeof(__pyx_k_stream_MACD), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MACDEXT, __pyx_k_stream_MACDEXT, sizeof(__pyx_k_stream_MACDEXT), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MACDFIX, __pyx_k_stream_MACDFIX, sizeof(__pyx_k_stream_MACDFIX), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MAMA, __pyx_k_stream_MAMA, sizeof(__pyx_k_stream_MAMA), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MAVP, __pyx_k_stream_MAVP, sizeof(__pyx_k_stream_MAVP), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MAX, __pyx_k_stream_MAX, sizeof(__pyx_k_stream_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MAXINDEX, __pyx_k_stream_MAXINDEX, sizeof(__pyx_k_stream_MAXINDEX), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MEDPRICE, __pyx_k_stream_MEDPRICE, sizeof(__pyx_k_stream_MEDPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MFI, __pyx_k_stream_MFI, sizeof(__pyx_k_stream_MFI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MIDPOINT, __pyx_k_stream_MIDPOINT, sizeof(__pyx_k_stream_MIDPOINT), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MIDPRICE, __pyx_k_stream_MIDPRICE, sizeof(__pyx_k_stream_MIDPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MIN, __pyx_k_stream_MIN, sizeof(__pyx_k_stream_MIN), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MININDEX, __pyx_k_stream_MININDEX, sizeof(__pyx_k_stream_MININDEX), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MINMAX, __pyx_k_stream_MINMAX, sizeof(__pyx_k_stream_MINMAX), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MINMAXINDEX, __pyx_k_stream_MINMAXINDEX, sizeof(__pyx_k_stream_MINMAXINDEX), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MINUS_DI, __pyx_k_stream_MINUS_DI, sizeof(__pyx_k_stream_MINUS_DI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MINUS_DM, __pyx_k_stream_MINUS_DM, sizeof(__pyx_k_stream_MINUS_DM), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MOM, __pyx_k_stream_MOM, sizeof(__pyx_k_stream_MOM), 0, 0, 1, 1}, - {&__pyx_n_s_stream_MULT, __pyx_k_stream_MULT, sizeof(__pyx_k_stream_MULT), 0, 0, 1, 1}, - {&__pyx_n_s_stream_NATR, __pyx_k_stream_NATR, sizeof(__pyx_k_stream_NATR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_OBV, __pyx_k_stream_OBV, sizeof(__pyx_k_stream_OBV), 0, 0, 1, 1}, - {&__pyx_n_s_stream_PLUS_DI, __pyx_k_stream_PLUS_DI, sizeof(__pyx_k_stream_PLUS_DI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_PLUS_DM, __pyx_k_stream_PLUS_DM, sizeof(__pyx_k_stream_PLUS_DM), 0, 0, 1, 1}, - {&__pyx_n_s_stream_PPO, __pyx_k_stream_PPO, sizeof(__pyx_k_stream_PPO), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ROC, __pyx_k_stream_ROC, sizeof(__pyx_k_stream_ROC), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ROCP, __pyx_k_stream_ROCP, sizeof(__pyx_k_stream_ROCP), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ROCR, __pyx_k_stream_ROCR, sizeof(__pyx_k_stream_ROCR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ROCR100, __pyx_k_stream_ROCR100, sizeof(__pyx_k_stream_ROCR100), 0, 0, 1, 1}, - {&__pyx_n_s_stream_RSI, __pyx_k_stream_RSI, sizeof(__pyx_k_stream_RSI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_SAR, __pyx_k_stream_SAR, sizeof(__pyx_k_stream_SAR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_SAREXT, __pyx_k_stream_SAREXT, sizeof(__pyx_k_stream_SAREXT), 0, 0, 1, 1}, - {&__pyx_n_s_stream_SIN, __pyx_k_stream_SIN, sizeof(__pyx_k_stream_SIN), 0, 0, 1, 1}, - {&__pyx_n_s_stream_SINH, __pyx_k_stream_SINH, sizeof(__pyx_k_stream_SINH), 0, 0, 1, 1}, - {&__pyx_n_s_stream_SMA, __pyx_k_stream_SMA, sizeof(__pyx_k_stream_SMA), 0, 0, 1, 1}, - {&__pyx_n_s_stream_SQRT, __pyx_k_stream_SQRT, sizeof(__pyx_k_stream_SQRT), 0, 0, 1, 1}, - {&__pyx_n_s_stream_STDDEV, __pyx_k_stream_STDDEV, sizeof(__pyx_k_stream_STDDEV), 0, 0, 1, 1}, - {&__pyx_n_s_stream_STOCH, __pyx_k_stream_STOCH, sizeof(__pyx_k_stream_STOCH), 0, 0, 1, 1}, - {&__pyx_n_s_stream_STOCHF, __pyx_k_stream_STOCHF, sizeof(__pyx_k_stream_STOCHF), 0, 0, 1, 1}, - {&__pyx_n_s_stream_STOCHRSI, __pyx_k_stream_STOCHRSI, sizeof(__pyx_k_stream_STOCHRSI), 0, 0, 1, 1}, - {&__pyx_n_s_stream_SUB, __pyx_k_stream_SUB, sizeof(__pyx_k_stream_SUB), 0, 0, 1, 1}, - {&__pyx_n_s_stream_SUM, __pyx_k_stream_SUM, sizeof(__pyx_k_stream_SUM), 0, 0, 1, 1}, - {&__pyx_n_s_stream_T3, __pyx_k_stream_T3, sizeof(__pyx_k_stream_T3), 0, 0, 1, 1}, - {&__pyx_n_s_stream_TAN, __pyx_k_stream_TAN, sizeof(__pyx_k_stream_TAN), 0, 0, 1, 1}, - {&__pyx_n_s_stream_TANH, __pyx_k_stream_TANH, sizeof(__pyx_k_stream_TANH), 0, 0, 1, 1}, - {&__pyx_n_s_stream_TEMA, __pyx_k_stream_TEMA, sizeof(__pyx_k_stream_TEMA), 0, 0, 1, 1}, - {&__pyx_n_s_stream_TRANGE, __pyx_k_stream_TRANGE, sizeof(__pyx_k_stream_TRANGE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_TRIMA, __pyx_k_stream_TRIMA, sizeof(__pyx_k_stream_TRIMA), 0, 0, 1, 1}, - {&__pyx_n_s_stream_TRIX, __pyx_k_stream_TRIX, sizeof(__pyx_k_stream_TRIX), 0, 0, 1, 1}, - {&__pyx_n_s_stream_TSF, __pyx_k_stream_TSF, sizeof(__pyx_k_stream_TSF), 0, 0, 1, 1}, - {&__pyx_n_s_stream_TYPPRICE, __pyx_k_stream_TYPPRICE, sizeof(__pyx_k_stream_TYPPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_ULTOSC, __pyx_k_stream_ULTOSC, sizeof(__pyx_k_stream_ULTOSC), 0, 0, 1, 1}, - {&__pyx_n_s_stream_VAR, __pyx_k_stream_VAR, sizeof(__pyx_k_stream_VAR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_WCLPRICE, __pyx_k_stream_WCLPRICE, sizeof(__pyx_k_stream_WCLPRICE), 0, 0, 1, 1}, - {&__pyx_n_s_stream_WILLR, __pyx_k_stream_WILLR, sizeof(__pyx_k_stream_WILLR), 0, 0, 1, 1}, - {&__pyx_n_s_stream_WMA, __pyx_k_stream_WMA, sizeof(__pyx_k_stream_WMA), 0, 0, 1, 1}, - {&__pyx_kp_s_stream__s, __pyx_k_stream__s, sizeof(__pyx_k_stream__s), 0, 0, 1, 0}, - {&__pyx_n_s_super, __pyx_k_super, sizeof(__pyx_k_super), 0, 0, 1, 1}, - {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, - {&__pyx_n_s_ta_check_success, __pyx_k_ta_check_success, sizeof(__pyx_k_ta_check_success), 0, 0, 1, 1}, - {&__pyx_n_s_ta_func_unst_ids, __pyx_k_ta_func_unst_ids, sizeof(__pyx_k_ta_func_unst_ids), 0, 0, 1, 1}, - {&__pyx_n_s_ta_getFuncInfo, __pyx_k_ta_getFuncInfo, sizeof(__pyx_k_ta_getFuncInfo), 0, 0, 1, 1}, - {&__pyx_n_s_ta_getFuncTable, __pyx_k_ta_getFuncTable, sizeof(__pyx_k_ta_getFuncTable), 0, 0, 1, 1}, - {&__pyx_n_s_ta_getGroupTable, __pyx_k_ta_getGroupTable, sizeof(__pyx_k_ta_getGroupTable), 0, 0, 1, 1}, - {&__pyx_n_s_ta_getInputParameterInfo, __pyx_k_ta_getInputParameterInfo, sizeof(__pyx_k_ta_getInputParameterInfo), 0, 0, 1, 1}, - {&__pyx_n_s_ta_getOptInputParameterInfo, __pyx_k_ta_getOptInputParameterInfo, sizeof(__pyx_k_ta_getOptInputParameterInfo), 0, 0, 1, 1}, - {&__pyx_n_s_ta_getOutputParameterInfo, __pyx_k_ta_getOutputParameterInfo, sizeof(__pyx_k_ta_getOutputParameterInfo), 0, 0, 1, 1}, - {&__pyx_n_s_ta_get_compatibility, __pyx_k_ta_get_compatibility, sizeof(__pyx_k_ta_get_compatibility), 0, 0, 1, 1}, - {&__pyx_n_s_ta_get_unstable_period, __pyx_k_ta_get_unstable_period, sizeof(__pyx_k_ta_get_unstable_period), 0, 0, 1, 1}, - {&__pyx_n_s_ta_initialize, __pyx_k_ta_initialize, sizeof(__pyx_k_ta_initialize), 0, 0, 1, 1}, - {&__pyx_n_s_ta_restore_candle_default_setti, __pyx_k_ta_restore_candle_default_setti, sizeof(__pyx_k_ta_restore_candle_default_setti), 0, 0, 1, 1}, - {&__pyx_n_s_ta_set_candle_settings, __pyx_k_ta_set_candle_settings, sizeof(__pyx_k_ta_set_candle_settings), 0, 0, 1, 1}, - {&__pyx_n_s_ta_set_compatibility, __pyx_k_ta_set_compatibility, sizeof(__pyx_k_ta_set_compatibility), 0, 0, 1, 1}, - {&__pyx_n_s_ta_set_unstable_period, __pyx_k_ta_set_unstable_period, sizeof(__pyx_k_ta_set_unstable_period), 0, 0, 1, 1}, - {&__pyx_n_s_ta_shutdown, __pyx_k_ta_shutdown, sizeof(__pyx_k_ta_shutdown), 0, 0, 1, 1}, - {&__pyx_n_s_ta_version, __pyx_k_ta_version, sizeof(__pyx_k_ta_version), 0, 0, 1, 1}, - {&__pyx_n_s_table, __pyx_k_table, sizeof(__pyx_k_table), 0, 0, 1, 1}, - {&__pyx_kp_s_talib__abstract_pxi, __pyx_k_talib__abstract_pxi, sizeof(__pyx_k_talib__abstract_pxi), 0, 0, 1, 0}, - {&__pyx_kp_s_talib__common_pxi, __pyx_k_talib__common_pxi, sizeof(__pyx_k_talib__common_pxi), 0, 0, 1, 0}, - {&__pyx_kp_s_talib__func_pxi, __pyx_k_talib__func_pxi, sizeof(__pyx_k_talib__func_pxi), 0, 0, 1, 0}, - {&__pyx_kp_s_talib__stream_pxi, __pyx_k_talib__stream_pxi, sizeof(__pyx_k_talib__stream_pxi), 0, 0, 1, 0}, - {&__pyx_n_s_talib__ta_lib, __pyx_k_talib__ta_lib, sizeof(__pyx_k_talib__ta_lib), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_threading, __pyx_k_threading, sizeof(__pyx_k_threading), 0, 0, 1, 1}, - {&__pyx_n_s_timeStamp, __pyx_k_timeStamp, sizeof(__pyx_k_timeStamp), 0, 0, 1, 1}, - {&__pyx_n_s_timeperiod, __pyx_k_timeperiod, sizeof(__pyx_k_timeperiod), 0, 0, 1, 1}, - {&__pyx_n_s_timeperiod1, __pyx_k_timeperiod1, sizeof(__pyx_k_timeperiod1), 0, 0, 1, 1}, - {&__pyx_n_s_timeperiod2, __pyx_k_timeperiod2, sizeof(__pyx_k_timeperiod2), 0, 0, 1, 1}, - {&__pyx_n_s_timeperiod3, __pyx_k_timeperiod3, sizeof(__pyx_k_timeperiod3), 0, 0, 1, 1}, - {&__pyx_n_s_to_numpy, __pyx_k_to_numpy, sizeof(__pyx_k_to_numpy), 0, 0, 1, 1}, - {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1}, - {&__pyx_n_s_type_2, __pyx_k_type_2, sizeof(__pyx_k_type_2), 0, 0, 1, 1}, - {&__pyx_n_s_unicode, __pyx_k_unicode, sizeof(__pyx_k_unicode), 0, 0, 1, 1}, - {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, - {&__pyx_n_s_update_info, __pyx_k_update_info, sizeof(__pyx_k_update_info), 0, 0, 1, 1}, - {&__pyx_n_s_upper, __pyx_k_upper, sizeof(__pyx_k_upper), 0, 0, 1, 1}, - {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, - {&__pyx_n_s_value_range, __pyx_k_value_range, sizeof(__pyx_k_value_range), 0, 0, 1, 1}, - {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1}, - {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, - {&__pyx_n_s_vfactor, __pyx_k_vfactor, sizeof(__pyx_k_vfactor), 0, 0, 1, 1}, - {&__pyx_n_s_volume, __pyx_k_volume, sizeof(__pyx_k_volume), 0, 0, 1, 1}, - {&__pyx_n_s_volume_data, __pyx_k_volume_data, sizeof(__pyx_k_volume_data), 0, 0, 1, 1}, - {&__pyx_n_s_xrange, __pyx_k_xrange, sizeof(__pyx_k_xrange), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} - }; - return __Pyx_InitStrings(__pyx_string_tab); -} -/* #### Code section: cached_builtins ### */ -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 60, __pyx_L1_error) - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 61, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 82, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 8, __pyx_L1_error) - __pyx_builtin_property = __Pyx_GetBuiltinName(__pyx_n_s_property); if (!__pyx_builtin_property) __PYX_ERR(1, 113, __pyx_L1_error) - #if PY_MAJOR_VERSION >= 3 - __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_xrange) __PYX_ERR(1, 130, __pyx_L1_error) - #else - __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_xrange); if (!__pyx_builtin_xrange) __PYX_ERR(1, 130, __pyx_L1_error) - #endif - __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 419, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 423, __pyx_L1_error) - __pyx_builtin_min = __Pyx_GetBuiltinName(__pyx_n_s_min); if (!__pyx_builtin_min) __PYX_ERR(1, 581, __pyx_L1_error) - __pyx_builtin_max = __Pyx_GetBuiltinName(__pyx_n_s_max); if (!__pyx_builtin_max) __PYX_ERR(1, 582, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: cached_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(2, 984, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple_); - __Pyx_GIVEREF(__pyx_tuple_); - - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(2, 990, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_input_array_type_is_not_double); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(3, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_input_array_has_wrong_dimensions); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(3, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_input_array_lengths_are_differen); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(3, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - - __pyx_tuple__8 = PyTuple_Pack(2, __pyx_n_s_real, __pyx_n_s_price); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 662, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - - __pyx_tuple__13 = PyTuple_Pack(2, __pyx_n_s_function_name, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_check_success, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 6, __pyx_L1_error) - - __pyx_tuple__15 = PyTuple_Pack(1, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); - __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_initialize, 50, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 50, __pyx_L1_error) - - __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_shutdown, 55, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 55, __pyx_L1_error) - - __pyx_tuple__18 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); - __pyx_tuple__19 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); - - __pyx_tuple__20 = PyTuple_Pack(1, __pyx_int_9); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); - - __pyx_tuple__21 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__21); - __Pyx_GIVEREF(__pyx_tuple__21); - __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_init, 63, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 63, __pyx_L1_error) - - __pyx_tuple__23 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_type); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__23); - __Pyx_GIVEREF(__pyx_tuple__23); - __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_getitem, 76, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 76, __pyx_L1_error) - - __pyx_tuple__25 = PyTuple_Pack(4, __pyx_n_s_name, __pyx_n_s_period, __pyx_n_s_ret_code, __pyx_n_s_id); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__25); - __Pyx_GIVEREF(__pyx_tuple__25); - __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_set_unstable_period, 90, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 90, __pyx_L1_error) - - __pyx_tuple__27 = PyTuple_Pack(3, __pyx_n_s_name, __pyx_n_s_period, __pyx_n_s_id); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__27); - __Pyx_GIVEREF(__pyx_tuple__27); - __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_get_unstable_period, 96, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 96, __pyx_L1_error) - - __pyx_tuple__29 = PyTuple_Pack(2, __pyx_n_s_value, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__29); - __Pyx_GIVEREF(__pyx_tuple__29); - __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_set_compatibility, 102, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 102, __pyx_L1_error) - - __pyx_tuple__31 = PyTuple_Pack(1, __pyx_n_s_value); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__31); - __Pyx_GIVEREF(__pyx_tuple__31); - __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_get_compatibility, 107, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 107, __pyx_L1_error) - - __pyx_tuple__33 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__33); - __Pyx_GIVEREF(__pyx_tuple__33); - __pyx_tuple__34 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__34); - __Pyx_GIVEREF(__pyx_tuple__34); - - __pyx_tuple__35 = PyTuple_Pack(1, __pyx_int_12); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 115, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__35); - __Pyx_GIVEREF(__pyx_tuple__35); - - __pyx_tuple__36 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__36); - __Pyx_GIVEREF(__pyx_tuple__36); - __pyx_tuple__37 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__37); - __Pyx_GIVEREF(__pyx_tuple__37); - - __pyx_tuple__38 = PyTuple_Pack(1, __pyx_int_3); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 120, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__38); - __Pyx_GIVEREF(__pyx_tuple__38); - - __pyx_tuple__39 = PyTuple_Pack(5, __pyx_n_s_settingtype, __pyx_n_s_rangetype, __pyx_n_s_avgperiod, __pyx_n_s_factor, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 124, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__39); - __Pyx_GIVEREF(__pyx_tuple__39); - __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__39, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_set_candle_settings, 124, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 124, __pyx_L1_error) - - __pyx_tuple__41 = PyTuple_Pack(2, __pyx_n_s_settingtype, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__41); - __Pyx_GIVEREF(__pyx_tuple__41); - __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_restore_candle_default_setti, 129, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(0, 129, __pyx_L1_error) - - __pyx_tuple__44 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(3, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__44); - __Pyx_GIVEREF(__pyx_tuple__44); - __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ACOS, 142, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(3, 142, __pyx_L1_error) - - __pyx_tuple__46 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(3, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__46); - __Pyx_GIVEREF(__pyx_tuple__46); - __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__46, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_AD, 171, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(3, 171, __pyx_L1_error) - - __pyx_tuple__48 = PyTuple_Pack(10, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(3, 203, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__48); - __Pyx_GIVEREF(__pyx_tuple__48); - __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ADD, 203, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(3, 203, __pyx_L1_error) - - __pyx_tuple__50 = PyTuple_Pack(14, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(3, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__50); - __Pyx_GIVEREF(__pyx_tuple__50); - __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__50, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ADOSC, 234, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(3, 234, __pyx_L1_error) - - __pyx_tuple__52 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(3, 269, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__52); - __Pyx_GIVEREF(__pyx_tuple__52); - __pyx_codeobj__53 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ADX, 269, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__53)) __PYX_ERR(3, 269, __pyx_L1_error) - - __pyx_codeobj__54 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ADXR, 302, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__54)) __PYX_ERR(3, 302, __pyx_L1_error) - - __pyx_tuple__55 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(3, 335, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__55); - __Pyx_GIVEREF(__pyx_tuple__55); - __pyx_codeobj__56 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_APO, 335, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__56)) __PYX_ERR(3, 335, __pyx_L1_error) - - __pyx_tuple__57 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outaroondown, __pyx_n_s_outaroonup); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(3, 368, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__57); - __Pyx_GIVEREF(__pyx_tuple__57); - __pyx_codeobj__58 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__57, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_AROON, 368, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__58)) __PYX_ERR(3, 368, __pyx_L1_error) - - __pyx_tuple__59 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(3, 403, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__59); - __Pyx_GIVEREF(__pyx_tuple__59); - __pyx_codeobj__60 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_AROONOSC, 403, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__60)) __PYX_ERR(3, 403, __pyx_L1_error) - - __pyx_codeobj__61 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ASIN, 435, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__61)) __PYX_ERR(3, 435, __pyx_L1_error) - - __pyx_codeobj__62 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ATAN, 464, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__62)) __PYX_ERR(3, 464, __pyx_L1_error) - - __pyx_codeobj__63 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ATR, 493, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__63)) __PYX_ERR(3, 493, __pyx_L1_error) - - __pyx_tuple__64 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(3, 526, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__64); - __Pyx_GIVEREF(__pyx_tuple__64); - __pyx_codeobj__65 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__64, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_AVGPRICE, 526, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__65)) __PYX_ERR(3, 526, __pyx_L1_error) - - __pyx_tuple__66 = PyTuple_Pack(15, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdevup, __pyx_n_s_nbdevdn, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outrealupperband, __pyx_n_s_outrealmiddleband, __pyx_n_s_outreallowerband); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(3, 558, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__66); - __Pyx_GIVEREF(__pyx_tuple__66); - __pyx_codeobj__67 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__66, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_BBANDS, 558, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__67)) __PYX_ERR(3, 558, __pyx_L1_error) - - __pyx_tuple__68 = PyTuple_Pack(11, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(3, 598, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__68); - __Pyx_GIVEREF(__pyx_tuple__68); - __pyx_codeobj__69 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__68, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_BETA, 598, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__69)) __PYX_ERR(3, 598, __pyx_L1_error) - - __pyx_codeobj__70 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__64, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_BOP, 631, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__70)) __PYX_ERR(3, 631, __pyx_L1_error) - - __pyx_codeobj__71 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CCI, 663, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__71)) __PYX_ERR(3, 663, __pyx_L1_error) - - __pyx_tuple__72 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(3, 696, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__72); - __Pyx_GIVEREF(__pyx_tuple__72); - __pyx_codeobj__73 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL2CROWS, 696, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__73)) __PYX_ERR(3, 696, __pyx_L1_error) - - __pyx_codeobj__74 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3BLACKCROWS, 728, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__74)) __PYX_ERR(3, 728, __pyx_L1_error) - - __pyx_codeobj__75 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3INSIDE, 760, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__75)) __PYX_ERR(3, 760, __pyx_L1_error) - - __pyx_codeobj__76 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3LINESTRIKE, 792, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__76)) __PYX_ERR(3, 792, __pyx_L1_error) - - __pyx_codeobj__77 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3OUTSIDE, 824, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__77)) __PYX_ERR(3, 824, __pyx_L1_error) - - __pyx_codeobj__78 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3STARSINSOUTH, 856, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__78)) __PYX_ERR(3, 856, __pyx_L1_error) - - __pyx_codeobj__79 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3WHITESOLDIERS, 888, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__79)) __PYX_ERR(3, 888, __pyx_L1_error) - - __pyx_tuple__80 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(3, 920, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__80); - __Pyx_GIVEREF(__pyx_tuple__80); - __pyx_codeobj__81 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLABANDONEDBABY, 920, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__81)) __PYX_ERR(3, 920, __pyx_L1_error) - - __pyx_codeobj__82 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLADVANCEBLOCK, 954, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__82)) __PYX_ERR(3, 954, __pyx_L1_error) - - __pyx_codeobj__83 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLBELTHOLD, 986, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__83)) __PYX_ERR(3, 986, __pyx_L1_error) - - __pyx_codeobj__84 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLBREAKAWAY, 1018, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__84)) __PYX_ERR(3, 1018, __pyx_L1_error) - - __pyx_codeobj__85 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLCLOSINGMARUBOZU, 1050, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__85)) __PYX_ERR(3, 1050, __pyx_L1_error) - - __pyx_codeobj__86 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLCONCEALBABYSWALL, 1082, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__86)) __PYX_ERR(3, 1082, __pyx_L1_error) - - __pyx_codeobj__87 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLCOUNTERATTACK, 1114, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__87)) __PYX_ERR(3, 1114, __pyx_L1_error) - - __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLDARKCLOUDCOVER, 1146, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) __PYX_ERR(3, 1146, __pyx_L1_error) - - __pyx_codeobj__89 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLDOJI, 1180, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__89)) __PYX_ERR(3, 1180, __pyx_L1_error) - - __pyx_codeobj__90 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLDOJISTAR, 1212, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__90)) __PYX_ERR(3, 1212, __pyx_L1_error) - - __pyx_codeobj__91 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLDRAGONFLYDOJI, 1244, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__91)) __PYX_ERR(3, 1244, __pyx_L1_error) - - __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLENGULFING, 1276, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) __PYX_ERR(3, 1276, __pyx_L1_error) - - __pyx_codeobj__93 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLEVENINGDOJISTAR, 1308, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__93)) __PYX_ERR(3, 1308, __pyx_L1_error) - - __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLEVENINGSTAR, 1342, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) __PYX_ERR(3, 1342, __pyx_L1_error) - - __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLGAPSIDESIDEWHITE, 1376, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) __PYX_ERR(3, 1376, __pyx_L1_error) - - __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLGRAVESTONEDOJI, 1408, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) __PYX_ERR(3, 1408, __pyx_L1_error) - - __pyx_codeobj__97 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHAMMER, 1440, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__97)) __PYX_ERR(3, 1440, __pyx_L1_error) - - __pyx_codeobj__98 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHANGINGMAN, 1472, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__98)) __PYX_ERR(3, 1472, __pyx_L1_error) - - __pyx_codeobj__99 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHARAMI, 1504, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__99)) __PYX_ERR(3, 1504, __pyx_L1_error) - - __pyx_codeobj__100 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHARAMICROSS, 1536, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__100)) __PYX_ERR(3, 1536, __pyx_L1_error) - - __pyx_codeobj__101 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHIGHWAVE, 1568, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__101)) __PYX_ERR(3, 1568, __pyx_L1_error) - - __pyx_codeobj__102 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHIKKAKE, 1600, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__102)) __PYX_ERR(3, 1600, __pyx_L1_error) - - __pyx_codeobj__103 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHIKKAKEMOD, 1632, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__103)) __PYX_ERR(3, 1632, __pyx_L1_error) - - __pyx_codeobj__104 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHOMINGPIGEON, 1664, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__104)) __PYX_ERR(3, 1664, __pyx_L1_error) - - __pyx_codeobj__105 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLIDENTICAL3CROWS, 1696, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__105)) __PYX_ERR(3, 1696, __pyx_L1_error) - - __pyx_codeobj__106 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLINNECK, 1728, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__106)) __PYX_ERR(3, 1728, __pyx_L1_error) - - __pyx_codeobj__107 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLINVERTEDHAMMER, 1760, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__107)) __PYX_ERR(3, 1760, __pyx_L1_error) - - __pyx_codeobj__108 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLKICKING, 1792, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__108)) __PYX_ERR(3, 1792, __pyx_L1_error) - - __pyx_codeobj__109 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLKICKINGBYLENGTH, 1824, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__109)) __PYX_ERR(3, 1824, __pyx_L1_error) - - __pyx_codeobj__110 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLLADDERBOTTOM, 1856, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__110)) __PYX_ERR(3, 1856, __pyx_L1_error) - - __pyx_codeobj__111 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLLONGLEGGEDDOJI, 1888, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__111)) __PYX_ERR(3, 1888, __pyx_L1_error) - - __pyx_codeobj__112 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLLONGLINE, 1920, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__112)) __PYX_ERR(3, 1920, __pyx_L1_error) - - __pyx_codeobj__113 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMARUBOZU, 1952, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__113)) __PYX_ERR(3, 1952, __pyx_L1_error) - - __pyx_codeobj__114 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMATCHINGLOW, 1984, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__114)) __PYX_ERR(3, 1984, __pyx_L1_error) - - __pyx_codeobj__115 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMATHOLD, 2016, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__115)) __PYX_ERR(3, 2016, __pyx_L1_error) - - __pyx_codeobj__116 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMORNINGDOJISTAR, 2050, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__116)) __PYX_ERR(3, 2050, __pyx_L1_error) - - __pyx_codeobj__117 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMORNINGSTAR, 2084, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__117)) __PYX_ERR(3, 2084, __pyx_L1_error) - - __pyx_codeobj__118 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLONNECK, 2118, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__118)) __PYX_ERR(3, 2118, __pyx_L1_error) - - __pyx_codeobj__119 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLPIERCING, 2150, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__119)) __PYX_ERR(3, 2150, __pyx_L1_error) - - __pyx_codeobj__120 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLRICKSHAWMAN, 2182, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__120)) __PYX_ERR(3, 2182, __pyx_L1_error) - - __pyx_codeobj__121 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLRISEFALL3METHODS, 2214, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__121)) __PYX_ERR(3, 2214, __pyx_L1_error) - - __pyx_codeobj__122 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSEPARATINGLINES, 2246, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__122)) __PYX_ERR(3, 2246, __pyx_L1_error) - - __pyx_codeobj__123 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSHOOTINGSTAR, 2278, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__123)) __PYX_ERR(3, 2278, __pyx_L1_error) - - __pyx_codeobj__124 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSHORTLINE, 2310, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__124)) __PYX_ERR(3, 2310, __pyx_L1_error) - - __pyx_codeobj__125 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSPINNINGTOP, 2342, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__125)) __PYX_ERR(3, 2342, __pyx_L1_error) - - __pyx_codeobj__126 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSTALLEDPATTERN, 2374, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__126)) __PYX_ERR(3, 2374, __pyx_L1_error) - - __pyx_codeobj__127 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSTICKSANDWICH, 2406, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__127)) __PYX_ERR(3, 2406, __pyx_L1_error) - - __pyx_codeobj__128 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLTAKURI, 2438, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__128)) __PYX_ERR(3, 2438, __pyx_L1_error) - - __pyx_codeobj__129 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLTASUKIGAP, 2470, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__129)) __PYX_ERR(3, 2470, __pyx_L1_error) - - __pyx_codeobj__130 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLTHRUSTING, 2502, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__130)) __PYX_ERR(3, 2502, __pyx_L1_error) - - __pyx_codeobj__131 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLTRISTAR, 2534, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__131)) __PYX_ERR(3, 2534, __pyx_L1_error) - - __pyx_codeobj__132 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLUNIQUE3RIVER, 2566, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__132)) __PYX_ERR(3, 2566, __pyx_L1_error) - - __pyx_codeobj__133 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLUPSIDEGAP2CROWS, 2598, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__133)) __PYX_ERR(3, 2598, __pyx_L1_error) - - __pyx_codeobj__134 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLXSIDEGAP3METHODS, 2630, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__134)) __PYX_ERR(3, 2630, __pyx_L1_error) - - __pyx_codeobj__135 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CEIL, 2662, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__135)) __PYX_ERR(3, 2662, __pyx_L1_error) - - __pyx_tuple__136 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__136)) __PYX_ERR(3, 2691, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__136); - __Pyx_GIVEREF(__pyx_tuple__136); - __pyx_codeobj__137 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CMO, 2691, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__137)) __PYX_ERR(3, 2691, __pyx_L1_error) - - __pyx_codeobj__138 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__68, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CORREL, 2722, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__138)) __PYX_ERR(3, 2722, __pyx_L1_error) - - __pyx_codeobj__139 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_COS, 2755, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__139)) __PYX_ERR(3, 2755, __pyx_L1_error) - - __pyx_codeobj__140 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_COSH, 2784, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__140)) __PYX_ERR(3, 2784, __pyx_L1_error) - - __pyx_codeobj__141 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_DEMA, 2813, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__141)) __PYX_ERR(3, 2813, __pyx_L1_error) - - __pyx_codeobj__142 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_DIV, 2844, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__142)) __PYX_ERR(3, 2844, __pyx_L1_error) - - __pyx_codeobj__143 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_DX, 2875, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__143)) __PYX_ERR(3, 2875, __pyx_L1_error) - - __pyx_codeobj__144 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_EMA, 2908, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__144)) __PYX_ERR(3, 2908, __pyx_L1_error) - - __pyx_codeobj__145 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_EXP, 2939, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__145)) __PYX_ERR(3, 2939, __pyx_L1_error) - - __pyx_codeobj__146 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_FLOOR, 2968, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__146)) __PYX_ERR(3, 2968, __pyx_L1_error) - - __pyx_codeobj__147 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_DCPERIOD, 2997, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__147)) __PYX_ERR(3, 2997, __pyx_L1_error) - - __pyx_codeobj__148 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_DCPHASE, 3026, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__148)) __PYX_ERR(3, 3026, __pyx_L1_error) - - __pyx_tuple__149 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinphase, __pyx_n_s_outquadrature); if (unlikely(!__pyx_tuple__149)) __PYX_ERR(3, 3055, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__149); - __Pyx_GIVEREF(__pyx_tuple__149); - __pyx_codeobj__150 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__149, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_PHASOR, 3055, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__150)) __PYX_ERR(3, 3055, __pyx_L1_error) - - __pyx_tuple__151 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outsine, __pyx_n_s_outleadsine); if (unlikely(!__pyx_tuple__151)) __PYX_ERR(3, 3087, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__151); - __Pyx_GIVEREF(__pyx_tuple__151); - __pyx_codeobj__152 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_SINE, 3087, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__152)) __PYX_ERR(3, 3087, __pyx_L1_error) - - __pyx_codeobj__153 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_TRENDLINE, 3119, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__153)) __PYX_ERR(3, 3119, __pyx_L1_error) - - __pyx_tuple__154 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__154)) __PYX_ERR(3, 3148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__154); - __Pyx_GIVEREF(__pyx_tuple__154); - __pyx_codeobj__155 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__154, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_TRENDMODE, 3148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__155)) __PYX_ERR(3, 3148, __pyx_L1_error) - - __pyx_codeobj__156 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_KAMA, 3177, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__156)) __PYX_ERR(3, 3177, __pyx_L1_error) - - __pyx_codeobj__157 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LINEARREG, 3208, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__157)) __PYX_ERR(3, 3208, __pyx_L1_error) - - __pyx_codeobj__158 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LINEARREG_ANGLE, 3239, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__158)) __PYX_ERR(3, 3239, __pyx_L1_error) - - __pyx_codeobj__159 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LINEARREG_INTERCEPT, 3270, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__159)) __PYX_ERR(3, 3270, __pyx_L1_error) - - __pyx_codeobj__160 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LINEARREG_SLOPE, 3301, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__160)) __PYX_ERR(3, 3301, __pyx_L1_error) - - __pyx_codeobj__161 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LN, 3332, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__161)) __PYX_ERR(3, 3332, __pyx_L1_error) - - __pyx_codeobj__162 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LOG10, 3361, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__162)) __PYX_ERR(3, 3361, __pyx_L1_error) - - __pyx_tuple__163 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__163)) __PYX_ERR(3, 3390, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__163); - __Pyx_GIVEREF(__pyx_tuple__163); - __pyx_codeobj__164 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__163, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MA, 3390, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__164)) __PYX_ERR(3, 3390, __pyx_L1_error) - - __pyx_tuple__165 = PyTuple_Pack(14, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_signalperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__165)) __PYX_ERR(3, 3422, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__165); - __Pyx_GIVEREF(__pyx_tuple__165); - __pyx_codeobj__166 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__165, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MACD, 3422, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__166)) __PYX_ERR(3, 3422, __pyx_L1_error) - - __pyx_tuple__167 = PyTuple_Pack(17, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_fastmatype, __pyx_n_s_slowperiod, __pyx_n_s_slowmatype, __pyx_n_s_signalperiod, __pyx_n_s_signalmatype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__167)) __PYX_ERR(3, 3461, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__167); - __Pyx_GIVEREF(__pyx_tuple__167); - __pyx_codeobj__168 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__167, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MACDEXT, 3461, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__168)) __PYX_ERR(3, 3461, __pyx_L1_error) - - __pyx_tuple__169 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_signalperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__169)) __PYX_ERR(3, 3503, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__169); - __Pyx_GIVEREF(__pyx_tuple__169); - __pyx_codeobj__170 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__169, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MACDFIX, 3503, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__170)) __PYX_ERR(3, 3503, __pyx_L1_error) - - __pyx_tuple__171 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_fastlimit, __pyx_n_s_slowlimit, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmama, __pyx_n_s_outfama); if (unlikely(!__pyx_tuple__171)) __PYX_ERR(3, 3540, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__171); - __Pyx_GIVEREF(__pyx_tuple__171); - __pyx_codeobj__172 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__171, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MAMA, 3540, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__172)) __PYX_ERR(3, 3540, __pyx_L1_error) - - __pyx_tuple__173 = PyTuple_Pack(13, __pyx_n_s_real, __pyx_n_s_periods, __pyx_n_s_minperiod, __pyx_n_s_maxperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__173)) __PYX_ERR(3, 3575, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__173); - __Pyx_GIVEREF(__pyx_tuple__173); - __pyx_codeobj__174 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__173, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MAVP, 3575, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__174)) __PYX_ERR(3, 3575, __pyx_L1_error) - - __pyx_codeobj__175 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MAX, 3610, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__175)) __PYX_ERR(3, 3610, __pyx_L1_error) - - __pyx_tuple__176 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger, __pyx_n_s_outinteger_data, __pyx_n_s_i); if (unlikely(!__pyx_tuple__176)) __PYX_ERR(3, 3641, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__176); - __Pyx_GIVEREF(__pyx_tuple__176); - __pyx_codeobj__177 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__176, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MAXINDEX, 3641, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__177)) __PYX_ERR(3, 3641, __pyx_L1_error) - - __pyx_tuple__178 = PyTuple_Pack(10, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__178)) __PYX_ERR(3, 3675, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__178); - __Pyx_GIVEREF(__pyx_tuple__178); - __pyx_codeobj__179 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__178, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MEDPRICE, 3675, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__179)) __PYX_ERR(3, 3675, __pyx_L1_error) - - __pyx_tuple__180 = PyTuple_Pack(13, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__180)) __PYX_ERR(3, 3705, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__180); - __Pyx_GIVEREF(__pyx_tuple__180); - __pyx_codeobj__181 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__180, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MFI, 3705, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__181)) __PYX_ERR(3, 3705, __pyx_L1_error) - - __pyx_codeobj__182 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MIDPOINT, 3739, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__182)) __PYX_ERR(3, 3739, __pyx_L1_error) - - __pyx_codeobj__183 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MIDPRICE, 3770, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__183)) __PYX_ERR(3, 3770, __pyx_L1_error) - - __pyx_codeobj__184 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MIN, 3802, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__184)) __PYX_ERR(3, 3802, __pyx_L1_error) - - __pyx_codeobj__185 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__176, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MININDEX, 3833, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__185)) __PYX_ERR(3, 3833, __pyx_L1_error) - - __pyx_tuple__186 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmin, __pyx_n_s_outmax); if (unlikely(!__pyx_tuple__186)) __PYX_ERR(3, 3867, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__186); - __Pyx_GIVEREF(__pyx_tuple__186); - __pyx_codeobj__187 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__186, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MINMAX, 3867, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__187)) __PYX_ERR(3, 3867, __pyx_L1_error) - - __pyx_tuple__188 = PyTuple_Pack(14, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outminidx, __pyx_n_s_outmaxidx, __pyx_n_s_outminidx_data, __pyx_n_s_i, __pyx_n_s_outmaxidx_data); if (unlikely(!__pyx_tuple__188)) __PYX_ERR(3, 3901, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__188); - __Pyx_GIVEREF(__pyx_tuple__188); - __pyx_codeobj__189 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__188, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MINMAXINDEX, 3901, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__189)) __PYX_ERR(3, 3901, __pyx_L1_error) - - __pyx_codeobj__190 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MINUS_DI, 3941, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__190)) __PYX_ERR(3, 3941, __pyx_L1_error) - - __pyx_codeobj__191 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MINUS_DM, 3974, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__191)) __PYX_ERR(3, 3974, __pyx_L1_error) - - __pyx_codeobj__192 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MOM, 4006, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__192)) __PYX_ERR(3, 4006, __pyx_L1_error) - - __pyx_codeobj__193 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MULT, 4037, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__193)) __PYX_ERR(3, 4037, __pyx_L1_error) - - __pyx_codeobj__194 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_NATR, 4068, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__194)) __PYX_ERR(3, 4068, __pyx_L1_error) - - __pyx_tuple__195 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_volume, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__195)) __PYX_ERR(3, 4101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__195); - __Pyx_GIVEREF(__pyx_tuple__195); - __pyx_codeobj__196 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__195, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_OBV, 4101, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__196)) __PYX_ERR(3, 4101, __pyx_L1_error) - - __pyx_codeobj__197 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_PLUS_DI, 4132, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__197)) __PYX_ERR(3, 4132, __pyx_L1_error) - - __pyx_codeobj__198 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_PLUS_DM, 4165, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__198)) __PYX_ERR(3, 4165, __pyx_L1_error) - - __pyx_codeobj__199 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_PPO, 4197, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__199)) __PYX_ERR(3, 4197, __pyx_L1_error) - - __pyx_codeobj__200 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ROC, 4230, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__200)) __PYX_ERR(3, 4230, __pyx_L1_error) - - __pyx_codeobj__201 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ROCP, 4261, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__201)) __PYX_ERR(3, 4261, __pyx_L1_error) - - __pyx_codeobj__202 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ROCR, 4292, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__202)) __PYX_ERR(3, 4292, __pyx_L1_error) - - __pyx_codeobj__203 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ROCR100, 4323, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__203)) __PYX_ERR(3, 4323, __pyx_L1_error) - - __pyx_codeobj__204 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_RSI, 4354, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__204)) __PYX_ERR(3, 4354, __pyx_L1_error) - - __pyx_tuple__205 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_acceleration, __pyx_n_s_maximum, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__205)) __PYX_ERR(3, 4385, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__205); - __Pyx_GIVEREF(__pyx_tuple__205); - __pyx_codeobj__206 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__205, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SAR, 4385, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__206)) __PYX_ERR(3, 4385, __pyx_L1_error) - - __pyx_tuple__207 = PyTuple_Pack(18, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_startvalue, __pyx_n_s_offsetonreverse, __pyx_n_s_accelerationinitlong, __pyx_n_s_accelerationlong, __pyx_n_s_accelerationmaxlong, __pyx_n_s_accelerationinitshort, __pyx_n_s_accelerationshort, __pyx_n_s_accelerationmaxshort, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__207)) __PYX_ERR(3, 4418, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__207); - __Pyx_GIVEREF(__pyx_tuple__207); - __pyx_codeobj__208 = (PyObject*)__Pyx_PyCode_New(10, 0, 0, 18, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__207, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SAREXT, 4418, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__208)) __PYX_ERR(3, 4418, __pyx_L1_error) - - __pyx_codeobj__209 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SIN, 4457, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__209)) __PYX_ERR(3, 4457, __pyx_L1_error) - - __pyx_codeobj__210 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SINH, 4486, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__210)) __PYX_ERR(3, 4486, __pyx_L1_error) - - __pyx_codeobj__211 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SMA, 4515, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__211)) __PYX_ERR(3, 4515, __pyx_L1_error) - - __pyx_codeobj__212 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SQRT, 4546, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__212)) __PYX_ERR(3, 4546, __pyx_L1_error) - - __pyx_tuple__213 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdev, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__213)) __PYX_ERR(3, 4575, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__213); - __Pyx_GIVEREF(__pyx_tuple__213); - __pyx_codeobj__214 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__213, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_STDDEV, 4575, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__214)) __PYX_ERR(3, 4575, __pyx_L1_error) - - __pyx_tuple__215 = PyTuple_Pack(17, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_fastk_period, __pyx_n_s_slowk_period, __pyx_n_s_slowk_matype, __pyx_n_s_slowd_period, __pyx_n_s_slowd_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outslowk, __pyx_n_s_outslowd); if (unlikely(!__pyx_tuple__215)) __PYX_ERR(3, 4607, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__215); - __Pyx_GIVEREF(__pyx_tuple__215); - __pyx_codeobj__216 = (PyObject*)__Pyx_PyCode_New(8, 0, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__215, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_STOCH, 4607, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__216)) __PYX_ERR(3, 4607, __pyx_L1_error) - - __pyx_tuple__217 = PyTuple_Pack(15, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_fastk_period, __pyx_n_s_fastd_period, __pyx_n_s_fastd_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outfastk, __pyx_n_s_outfastd); if (unlikely(!__pyx_tuple__217)) __PYX_ERR(3, 4647, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__217); - __Pyx_GIVEREF(__pyx_tuple__217); - __pyx_codeobj__218 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__217, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_STOCHF, 4647, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__218)) __PYX_ERR(3, 4647, __pyx_L1_error) - - __pyx_tuple__219 = PyTuple_Pack(14, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_fastk_period, __pyx_n_s_fastd_period, __pyx_n_s_fastd_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outfastk, __pyx_n_s_outfastd); if (unlikely(!__pyx_tuple__219)) __PYX_ERR(3, 4685, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__219); - __Pyx_GIVEREF(__pyx_tuple__219); - __pyx_codeobj__220 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__219, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_STOCHRSI, 4685, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__220)) __PYX_ERR(3, 4685, __pyx_L1_error) - - __pyx_codeobj__221 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SUB, 4722, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__221)) __PYX_ERR(3, 4722, __pyx_L1_error) - - __pyx_codeobj__222 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SUM, 4753, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__222)) __PYX_ERR(3, 4753, __pyx_L1_error) - - __pyx_tuple__223 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_vfactor, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__223)) __PYX_ERR(3, 4784, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__223); - __Pyx_GIVEREF(__pyx_tuple__223); - __pyx_codeobj__224 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__223, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_T3, 4784, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__224)) __PYX_ERR(3, 4784, __pyx_L1_error) - - __pyx_codeobj__225 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TAN, 4816, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__225)) __PYX_ERR(3, 4816, __pyx_L1_error) - - __pyx_codeobj__226 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TANH, 4845, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__226)) __PYX_ERR(3, 4845, __pyx_L1_error) - - __pyx_codeobj__227 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TEMA, 4874, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__227)) __PYX_ERR(3, 4874, __pyx_L1_error) - - __pyx_tuple__228 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__228)) __PYX_ERR(3, 4905, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__228); - __Pyx_GIVEREF(__pyx_tuple__228); - __pyx_codeobj__229 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__228, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TRANGE, 4905, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__229)) __PYX_ERR(3, 4905, __pyx_L1_error) - - __pyx_codeobj__230 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TRIMA, 4936, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__230)) __PYX_ERR(3, 4936, __pyx_L1_error) - - __pyx_codeobj__231 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TRIX, 4967, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__231)) __PYX_ERR(3, 4967, __pyx_L1_error) - - __pyx_codeobj__232 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TSF, 4998, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__232)) __PYX_ERR(3, 4998, __pyx_L1_error) - - __pyx_codeobj__233 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__228, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TYPPRICE, 5029, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__233)) __PYX_ERR(3, 5029, __pyx_L1_error) - - __pyx_tuple__234 = PyTuple_Pack(14, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod1, __pyx_n_s_timeperiod2, __pyx_n_s_timeperiod3, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__234)) __PYX_ERR(3, 5060, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__234); - __Pyx_GIVEREF(__pyx_tuple__234); - __pyx_codeobj__235 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__234, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ULTOSC, 5060, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__235)) __PYX_ERR(3, 5060, __pyx_L1_error) - - __pyx_codeobj__236 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__213, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_VAR, 5095, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__236)) __PYX_ERR(3, 5095, __pyx_L1_error) - - __pyx_codeobj__237 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__228, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_WCLPRICE, 5127, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__237)) __PYX_ERR(3, 5127, __pyx_L1_error) - - __pyx_codeobj__238 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_WILLR, 5158, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__238)) __PYX_ERR(3, 5158, __pyx_L1_error) - - __pyx_codeobj__239 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_WMA, 5191, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__239)) __PYX_ERR(3, 5191, __pyx_L1_error) - - __pyx_tuple__241 = PyTuple_Pack(1, __pyx_n_s_s); if (unlikely(!__pyx_tuple__241)) __PYX_ERR(1, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__241); - __Pyx_GIVEREF(__pyx_tuple__241); - __pyx_codeobj__242 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__241, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_str2bytes, 57, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__242)) __PYX_ERR(1, 57, __pyx_L1_error) - - __pyx_tuple__243 = PyTuple_Pack(1, __pyx_n_s_b); if (unlikely(!__pyx_tuple__243)) __PYX_ERR(1, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__243); - __Pyx_GIVEREF(__pyx_tuple__243); - __pyx_codeobj__244 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__243, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_bytes2str, 60, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__244)) __PYX_ERR(1, 60, __pyx_L1_error) - - __pyx_codeobj__245 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__241, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_str2bytes, 65, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__245)) __PYX_ERR(1, 65, __pyx_L1_error) - - __pyx_codeobj__246 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__243, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_bytes2str, 68, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__246)) __PYX_ERR(1, 68, __pyx_L1_error) - - __pyx_tuple__247 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__247)) __PYX_ERR(1, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__247); - __Pyx_GIVEREF(__pyx_tuple__247); - __pyx_tuple__248 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__248)) __PYX_ERR(1, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__248); - __Pyx_GIVEREF(__pyx_tuple__248); - - __pyx_tuple__249 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_function_name, __pyx_n_s_func_object, __pyx_n_s_args, __pyx_n_s_kwargs); if (unlikely(!__pyx_tuple__249)) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__249); - __Pyx_GIVEREF(__pyx_tuple__249); - __pyx_codeobj__250 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__249, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_init, 100, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__250)) __PYX_ERR(1, 100, __pyx_L1_error) - - __pyx_tuple__251 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_local, __pyx_n_s_i, __pyx_n_s_info, __pyx_n_s_input_name, __pyx_n_s_param_name, __pyx_n_s_output_name); if (unlikely(!__pyx_tuple__251)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__251); - __Pyx_GIVEREF(__pyx_tuple__251); - __pyx_codeobj__252 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__251, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_local_2, 113, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__252)) __PYX_ERR(1, 113, __pyx_L1_error) - - __pyx_codeobj__253 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_info, 155, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__253)) __PYX_ERR(1, 155, __pyx_L1_error) - - __pyx_codeobj__254 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_function_flags, 162, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__254)) __PYX_ERR(1, 162, __pyx_L1_error) - - __pyx_codeobj__255 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_output_flags, 169, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__255)) __PYX_ERR(1, 169, __pyx_L1_error) - - __pyx_tuple__256 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_local, __pyx_n_s_ret, __pyx_n_s_input_name); if (unlikely(!__pyx_tuple__256)) __PYX_ERR(1, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__256); - __Pyx_GIVEREF(__pyx_tuple__256); - __pyx_codeobj__257 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__256, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_input_names, 176, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__257)) __PYX_ERR(1, 176, __pyx_L1_error) - - __pyx_tuple__258 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_input_names, __pyx_n_s_local, __pyx_n_s_input_name, __pyx_n_s_price_series); if (unlikely(!__pyx_tuple__258)) __PYX_ERR(1, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__258); - __Pyx_GIVEREF(__pyx_tuple__258); - __pyx_codeobj__259 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__258, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_set_input_names, 187, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__259)) __PYX_ERR(1, 187, __pyx_L1_error) - - __pyx_tuple__260 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_local); if (unlikely(!__pyx_tuple__260)) __PYX_ERR(1, 199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__260); - __Pyx_GIVEREF(__pyx_tuple__260); - __pyx_codeobj__261 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__260, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_input_arrays, 199, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__261)) __PYX_ERR(1, 199, __pyx_L1_error) - - __pyx_tuple__262 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_input_arrays, __pyx_n_s_local, __pyx_n_s_missing_keys, __pyx_n_s_key, __pyx_n_s_missing); if (unlikely(!__pyx_tuple__262)) __PYX_ERR(1, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__262); - __Pyx_GIVEREF(__pyx_tuple__262); - __pyx_codeobj__263 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__262, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_set_input_arrays, 210, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__263)) __PYX_ERR(1, 210, __pyx_L1_error) - - __pyx_tuple__264 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_local, __pyx_n_s_ret, __pyx_n_s_opt_input); if (unlikely(!__pyx_tuple__264)) __PYX_ERR(1, 259, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__264); - __Pyx_GIVEREF(__pyx_tuple__264); - __pyx_codeobj__265 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__264, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_parameters, 259, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__265)) __PYX_ERR(1, 259, __pyx_L1_error) - - __pyx_tuple__266 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_parameters, __pyx_n_s_kwargs, __pyx_n_s_local, __pyx_n_s_param, __pyx_n_s_value); if (unlikely(!__pyx_tuple__266)) __PYX_ERR(1, 269, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__266); - __Pyx_GIVEREF(__pyx_tuple__266); - __pyx_codeobj__267 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__266, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_set_parameters, 269, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__267)) __PYX_ERR(1, 269, __pyx_L1_error) - __pyx_tuple__268 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__268)) __PYX_ERR(1, 269, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__268); - __Pyx_GIVEREF(__pyx_tuple__268); - - __pyx_tuple__269 = PyTuple_Pack(10, __pyx_n_s_self, __pyx_n_s_args, __pyx_n_s_kwargs, __pyx_n_s_local, __pyx_n_s_update_info, __pyx_n_s_key, __pyx_n_s_value, __pyx_n_s_skip_first, __pyx_n_s_i, __pyx_n_s_param_name); if (unlikely(!__pyx_tuple__269)) __PYX_ERR(1, 284, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__269); - __Pyx_GIVEREF(__pyx_tuple__269); - __pyx_codeobj__270 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__269, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_set_function_args, 284, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__270)) __PYX_ERR(1, 284, __pyx_L1_error) - - __pyx_tuple__271 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_local, __pyx_n_s_holder, __pyx_n_s_i, __pyx_n_s_opt_input, __pyx_n_s_value, __pyx_n_s_type, __pyx_n_s_lookback); if (unlikely(!__pyx_tuple__271)) __PYX_ERR(1, 319, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__271); - __Pyx_GIVEREF(__pyx_tuple__271); - __pyx_codeobj__272 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__271, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_lookback, 319, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__272)) __PYX_ERR(1, 319, __pyx_L1_error) - - __pyx_tuple__273 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_ret); if (unlikely(!__pyx_tuple__273)) __PYX_ERR(1, 340, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__273); - __Pyx_GIVEREF(__pyx_tuple__273); - __pyx_codeobj__274 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__273, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_output_names, 340, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__274)) __PYX_ERR(1, 340, __pyx_L1_error) - - __pyx_tuple__275 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_local, __pyx_n_s_ret, __pyx_n_s_index); if (unlikely(!__pyx_tuple__275)) __PYX_ERR(1, 350, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__275); - __Pyx_GIVEREF(__pyx_tuple__275); - __pyx_codeobj__276 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__275, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_outputs, 350, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__276)) __PYX_ERR(1, 350, __pyx_L1_error) - - __pyx_tuple__277 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_input_arrays); if (unlikely(!__pyx_tuple__277)) __PYX_ERR(1, 382, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__277); - __Pyx_GIVEREF(__pyx_tuple__277); - __pyx_codeobj__278 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__277, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_run, 382, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__278)) __PYX_ERR(1, 382, __pyx_L1_error) - - __pyx_tuple__279 = PyTuple_Pack(16, __pyx_n_s_self, __pyx_n_s_args, __pyx_n_s_kwargs, __pyx_n_s_local, __pyx_n_s_opt_input_values, __pyx_n_s_price_series_name_values, __pyx_n_s_input_arrays, __pyx_n_s_input_price_series_names, __pyx_n_s_i, __pyx_n_s_arg, __pyx_n_s_msg, __pyx_n_s_no_existing_input_arrays, __pyx_n_s_param_name, __pyx_n_s_value, __pyx_n_s_input_name, __pyx_n_s_n); if (unlikely(!__pyx_tuple__279)) __PYX_ERR(1, 394, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__279); - __Pyx_GIVEREF(__pyx_tuple__279); - __pyx_codeobj__280 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 16, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__279, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_call, 394, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__280)) __PYX_ERR(1, 394, __pyx_L1_error) - - __pyx_tuple__281 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_local, __pyx_n_s_input_price_series_names, __pyx_n_s_input_name, __pyx_n_s_price_series, __pyx_n_s_name); if (unlikely(!__pyx_tuple__281)) __PYX_ERR(1, 460, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__281); - __Pyx_GIVEREF(__pyx_tuple__281); - __pyx_codeobj__282 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__281, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_input_price_series_names_2, 460, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__282)) __PYX_ERR(1, 460, __pyx_L1_error) - - __pyx_tuple__283 = PyTuple_Pack(12, __pyx_n_s_self, __pyx_n_s_local, __pyx_n_s_input_price_series_names, __pyx_n_s_args, __pyx_n_s_price_series, __pyx_n_s_series, __pyx_n_s_opt_input, __pyx_n_s_value, __pyx_n_s_results, __pyx_n_s_keys, __pyx_n_s_i, __pyx_n_s_output); if (unlikely(!__pyx_tuple__283)) __PYX_ERR(1, 472, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__283); - __Pyx_GIVEREF(__pyx_tuple__283); - __pyx_codeobj__284 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__283, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_call_function, 472, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__284)) __PYX_ERR(1, 472, __pyx_L1_error) - - __pyx_tuple__285 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_input_name, __pyx_n_s_value, __pyx_n_s_type); if (unlikely(!__pyx_tuple__285)) __PYX_ERR(1, 503, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__285); - __Pyx_GIVEREF(__pyx_tuple__285); - __pyx_codeobj__286 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__285, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_check_opt_input_value, 503, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__286)) __PYX_ERR(1, 503, __pyx_L1_error) - - __pyx_tuple__287 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_input_name, __pyx_n_s_local, __pyx_n_s_value); if (unlikely(!__pyx_tuple__287)) __PYX_ERR(1, 518, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__287); - __Pyx_GIVEREF(__pyx_tuple__287); - __pyx_codeobj__288 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__287, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_opt_input_value, 518, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__288)) __PYX_ERR(1, 518, __pyx_L1_error) - - __pyx_codeobj__289 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_repr, 528, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__289)) __PYX_ERR(1, 528, __pyx_L1_error) - - __pyx_codeobj__290 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_unicode, 531, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__290)) __PYX_ERR(1, 531, __pyx_L1_error) - - __pyx_codeobj__291 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_str, 534, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__291)) __PYX_ERR(1, 534, __pyx_L1_error) - - __pyx_tuple__292 = PyTuple_Pack(3, __pyx_n_s_table, __pyx_n_s_groups, __pyx_n_s_i); if (unlikely(!__pyx_tuple__292)) __PYX_ERR(1, 548, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__292); - __Pyx_GIVEREF(__pyx_tuple__292); - __pyx_codeobj__293 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__292, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getGroupTable, 548, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__293)) __PYX_ERR(1, 548, __pyx_L1_error) - - __pyx_tuple__294 = PyTuple_Pack(4, __pyx_n_s_group, __pyx_n_s_table, __pyx_n_s_functions, __pyx_n_s_i); if (unlikely(!__pyx_tuple__294)) __PYX_ERR(1, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__294); - __Pyx_GIVEREF(__pyx_tuple__294); - __pyx_codeobj__295 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__294, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getFuncTable, 560, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__295)) __PYX_ERR(1, 560, __pyx_L1_error) - - __pyx_tuple__296 = PyTuple_Pack(7, __pyx_n_s_flag, __pyx_n_s_flags_lookup_dict, __pyx_n_s_value_range, __pyx_n_s_min_int, __pyx_n_s_max_int, __pyx_n_s_ret, __pyx_n_s_i); if (unlikely(!__pyx_tuple__296)) __PYX_ERR(1, 572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__296); - __Pyx_GIVEREF(__pyx_tuple__296); - __pyx_codeobj__297 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__296, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_flags, 572, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__297)) __PYX_ERR(1, 572, __pyx_L1_error) - - __pyx_tuple__298 = PyTuple_Pack(3, __pyx_n_s_function_name, __pyx_n_s_info, __pyx_n_s_retCode); if (unlikely(!__pyx_tuple__298)) __PYX_ERR(1, 631, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__298); - __Pyx_GIVEREF(__pyx_tuple__298); - __pyx_codeobj__299 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__298, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getFuncInfo, 631, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__299)) __PYX_ERR(1, 631, __pyx_L1_error) - - __pyx_tuple__300 = PyTuple_Pack(5, __pyx_n_s_function_name, __pyx_n_s_idx, __pyx_n_s_info, __pyx_n_s_retCode, __pyx_n_s_name); if (unlikely(!__pyx_tuple__300)) __PYX_ERR(1, 650, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__300); - __Pyx_GIVEREF(__pyx_tuple__300); - __pyx_codeobj__301 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__300, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getInputParameterInfo, 650, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__301)) __PYX_ERR(1, 650, __pyx_L1_error) - - __pyx_tuple__302 = PyTuple_Pack(6, __pyx_n_s_function_name, __pyx_n_s_idx, __pyx_n_s_info, __pyx_n_s_retCode, __pyx_n_s_name, __pyx_n_s_default_value); if (unlikely(!__pyx_tuple__302)) __PYX_ERR(1, 671, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__302); - __Pyx_GIVEREF(__pyx_tuple__302); - __pyx_codeobj__303 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__302, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getOptInputParameterInfo, 671, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__303)) __PYX_ERR(1, 671, __pyx_L1_error) - - __pyx_codeobj__304 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__300, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getOutputParameterInfo, 695, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__304)) __PYX_ERR(1, 695, __pyx_L1_error) - - __pyx_tuple__305 = PyTuple_Pack(13, __pyx_n_s_func_info, __pyx_n_s_defaults, __pyx_n_s_func_line, __pyx_n_s_func_args, __pyx_n_s_docs, __pyx_n_s_input_names, __pyx_n_s_input_name, __pyx_n_s_value, __pyx_n_s_params, __pyx_n_s_param, __pyx_n_s_outputs, __pyx_n_s_output, __pyx_n_s_documentation); if (unlikely(!__pyx_tuple__305)) __PYX_ERR(1, 715, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__305); - __Pyx_GIVEREF(__pyx_tuple__305); - __pyx_codeobj__306 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__305, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_defaults_and_docs, 715, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__306)) __PYX_ERR(1, 715, __pyx_L1_error) - - __pyx_tuple__307 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__307)) __PYX_ERR(4, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__307); - __Pyx_GIVEREF(__pyx_tuple__307); - __pyx_codeobj__308 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ACOS, 9, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__308)) __PYX_ERR(4, 9, __pyx_L1_error) - - __pyx_tuple__309 = PyTuple_Pack(13, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_volume_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__309)) __PYX_ERR(4, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__309); - __Pyx_GIVEREF(__pyx_tuple__309); - __pyx_codeobj__310 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__309, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_AD, 36, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__310)) __PYX_ERR(4, 36, __pyx_L1_error) - - __pyx_tuple__311 = PyTuple_Pack(9, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real0_data, __pyx_n_s_real1_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__311)) __PYX_ERR(4, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__311); - __Pyx_GIVEREF(__pyx_tuple__311); - __pyx_codeobj__312 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__311, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ADD, 72, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__312)) __PYX_ERR(4, 72, __pyx_L1_error) - - __pyx_tuple__313 = PyTuple_Pack(15, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_volume_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__313)) __PYX_ERR(4, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__313); - __Pyx_GIVEREF(__pyx_tuple__313); - __pyx_codeobj__314 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__313, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ADOSC, 103, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__314)) __PYX_ERR(4, 103, __pyx_L1_error) - - __pyx_tuple__315 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__315)) __PYX_ERR(4, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__315); - __Pyx_GIVEREF(__pyx_tuple__315); - __pyx_codeobj__316 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ADX, 142, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__316)) __PYX_ERR(4, 142, __pyx_L1_error) - - __pyx_codeobj__317 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ADXR, 177, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__317)) __PYX_ERR(4, 177, __pyx_L1_error) - - __pyx_tuple__318 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__318)) __PYX_ERR(4, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__318); - __Pyx_GIVEREF(__pyx_tuple__318); - __pyx_codeobj__319 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__318, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_APO, 212, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__319)) __PYX_ERR(4, 212, __pyx_L1_error) - - __pyx_tuple__320 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outaroondown, __pyx_n_s_outaroonup); if (unlikely(!__pyx_tuple__320)) __PYX_ERR(4, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__320); - __Pyx_GIVEREF(__pyx_tuple__320); - __pyx_codeobj__321 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__320, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_AROON, 243, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__321)) __PYX_ERR(4, 243, __pyx_L1_error) - - __pyx_tuple__322 = PyTuple_Pack(10, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__322)) __PYX_ERR(4, 278, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__322); - __Pyx_GIVEREF(__pyx_tuple__322); - __pyx_codeobj__323 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__322, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_AROONOSC, 278, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__323)) __PYX_ERR(4, 278, __pyx_L1_error) - - __pyx_codeobj__324 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ASIN, 310, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__324)) __PYX_ERR(4, 310, __pyx_L1_error) - - __pyx_codeobj__325 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ATAN, 337, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__325)) __PYX_ERR(4, 337, __pyx_L1_error) - - __pyx_codeobj__326 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ATR, 364, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__326)) __PYX_ERR(4, 364, __pyx_L1_error) - - __pyx_tuple__327 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__327)) __PYX_ERR(4, 399, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__327); - __Pyx_GIVEREF(__pyx_tuple__327); - __pyx_codeobj__328 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__327, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_AVGPRICE, 399, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__328)) __PYX_ERR(4, 399, __pyx_L1_error) - - __pyx_tuple__329 = PyTuple_Pack(13, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdevup, __pyx_n_s_nbdevdn, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outrealupperband, __pyx_n_s_outrealmiddleband, __pyx_n_s_outreallowerband); if (unlikely(!__pyx_tuple__329)) __PYX_ERR(4, 435, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__329); - __Pyx_GIVEREF(__pyx_tuple__329); - __pyx_codeobj__330 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__329, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_BBANDS, 435, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__330)) __PYX_ERR(4, 435, __pyx_L1_error) - - __pyx_tuple__331 = PyTuple_Pack(10, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real0_data, __pyx_n_s_real1_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__331)) __PYX_ERR(4, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__331); - __Pyx_GIVEREF(__pyx_tuple__331); - __pyx_codeobj__332 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__331, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_BETA, 473, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__332)) __PYX_ERR(4, 473, __pyx_L1_error) - - __pyx_codeobj__333 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__327, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_BOP, 506, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__333)) __PYX_ERR(4, 506, __pyx_L1_error) - - __pyx_codeobj__334 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CCI, 542, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__334)) __PYX_ERR(4, 542, __pyx_L1_error) - - __pyx_tuple__335 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__335)) __PYX_ERR(4, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__335); - __Pyx_GIVEREF(__pyx_tuple__335); - __pyx_codeobj__336 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL2CROWS, 577, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__336)) __PYX_ERR(4, 577, __pyx_L1_error) - - __pyx_codeobj__337 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3BLACKCROWS, 613, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__337)) __PYX_ERR(4, 613, __pyx_L1_error) - - __pyx_codeobj__338 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3INSIDE, 649, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__338)) __PYX_ERR(4, 649, __pyx_L1_error) - - __pyx_codeobj__339 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3LINESTRIKE, 685, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__339)) __PYX_ERR(4, 685, __pyx_L1_error) - - __pyx_codeobj__340 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3OUTSIDE, 721, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__340)) __PYX_ERR(4, 721, __pyx_L1_error) - - __pyx_codeobj__341 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3STARSINSOUTH, 757, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__341)) __PYX_ERR(4, 757, __pyx_L1_error) - - __pyx_codeobj__342 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3WHITESOLDIERS, 793, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__342)) __PYX_ERR(4, 793, __pyx_L1_error) - - __pyx_tuple__343 = PyTuple_Pack(14, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__343)) __PYX_ERR(4, 829, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__343); - __Pyx_GIVEREF(__pyx_tuple__343); - __pyx_codeobj__344 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__343, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLABANDONEDBABY, 829, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__344)) __PYX_ERR(4, 829, __pyx_L1_error) - - __pyx_codeobj__345 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLADVANCEBLOCK, 867, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__345)) __PYX_ERR(4, 867, __pyx_L1_error) - - __pyx_codeobj__346 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLBELTHOLD, 903, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__346)) __PYX_ERR(4, 903, __pyx_L1_error) - - __pyx_codeobj__347 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLBREAKAWAY, 939, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__347)) __PYX_ERR(4, 939, __pyx_L1_error) - - __pyx_codeobj__348 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLCLOSINGMARUBOZU, 975, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__348)) __PYX_ERR(4, 975, __pyx_L1_error) - - __pyx_codeobj__349 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLCONCEALBABYSWALL, 1011, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__349)) __PYX_ERR(4, 1011, __pyx_L1_error) - - __pyx_codeobj__350 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLCOUNTERATTACK, 1047, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__350)) __PYX_ERR(4, 1047, __pyx_L1_error) - - __pyx_codeobj__351 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__343, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLDARKCLOUDCOVER, 1083, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__351)) __PYX_ERR(4, 1083, __pyx_L1_error) - - __pyx_codeobj__352 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLDOJI, 1121, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__352)) __PYX_ERR(4, 1121, __pyx_L1_error) - - __pyx_codeobj__353 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLDOJISTAR, 1157, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__353)) __PYX_ERR(4, 1157, __pyx_L1_error) - - __pyx_codeobj__354 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLDRAGONFLYDOJI, 1193, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__354)) __PYX_ERR(4, 1193, __pyx_L1_error) - - __pyx_codeobj__355 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLENGULFING, 1229, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__355)) __PYX_ERR(4, 1229, __pyx_L1_error) - - __pyx_codeobj__356 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__343, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLEVENINGDOJISTAR, 1265, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__356)) __PYX_ERR(4, 1265, __pyx_L1_error) - - __pyx_codeobj__357 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__343, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLEVENINGSTAR, 1303, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__357)) __PYX_ERR(4, 1303, __pyx_L1_error) - - __pyx_codeobj__358 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLGAPSIDESIDEWHITE, 1341, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__358)) __PYX_ERR(4, 1341, __pyx_L1_error) - - __pyx_codeobj__359 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLGRAVESTONEDOJI, 1377, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__359)) __PYX_ERR(4, 1377, __pyx_L1_error) - - __pyx_codeobj__360 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHAMMER, 1413, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__360)) __PYX_ERR(4, 1413, __pyx_L1_error) - - __pyx_codeobj__361 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHANGINGMAN, 1449, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__361)) __PYX_ERR(4, 1449, __pyx_L1_error) - - __pyx_codeobj__362 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHARAMI, 1485, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__362)) __PYX_ERR(4, 1485, __pyx_L1_error) - - __pyx_codeobj__363 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHARAMICROSS, 1521, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__363)) __PYX_ERR(4, 1521, __pyx_L1_error) - - __pyx_codeobj__364 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHIGHWAVE, 1557, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__364)) __PYX_ERR(4, 1557, __pyx_L1_error) - - __pyx_codeobj__365 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHIKKAKE, 1593, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__365)) __PYX_ERR(4, 1593, __pyx_L1_error) - - __pyx_codeobj__366 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHIKKAKEMOD, 1629, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__366)) __PYX_ERR(4, 1629, __pyx_L1_error) - - __pyx_codeobj__367 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHOMINGPIGEON, 1665, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__367)) __PYX_ERR(4, 1665, __pyx_L1_error) - - __pyx_codeobj__368 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLIDENTICAL3CROWS, 1701, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__368)) __PYX_ERR(4, 1701, __pyx_L1_error) - - __pyx_codeobj__369 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLINNECK, 1737, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__369)) __PYX_ERR(4, 1737, __pyx_L1_error) - - __pyx_codeobj__370 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLINVERTEDHAMMER, 1773, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__370)) __PYX_ERR(4, 1773, __pyx_L1_error) - - __pyx_codeobj__371 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLKICKING, 1809, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__371)) __PYX_ERR(4, 1809, __pyx_L1_error) - - __pyx_codeobj__372 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLKICKINGBYLENGTH, 1845, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__372)) __PYX_ERR(4, 1845, __pyx_L1_error) - - __pyx_codeobj__373 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLLADDERBOTTOM, 1881, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__373)) __PYX_ERR(4, 1881, __pyx_L1_error) - - __pyx_codeobj__374 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLLONGLEGGEDDOJI, 1917, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__374)) __PYX_ERR(4, 1917, __pyx_L1_error) - - __pyx_codeobj__375 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLLONGLINE, 1953, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__375)) __PYX_ERR(4, 1953, __pyx_L1_error) - - __pyx_codeobj__376 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMARUBOZU, 1989, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__376)) __PYX_ERR(4, 1989, __pyx_L1_error) - - __pyx_codeobj__377 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMATCHINGLOW, 2025, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__377)) __PYX_ERR(4, 2025, __pyx_L1_error) - - __pyx_codeobj__378 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__343, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMATHOLD, 2061, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__378)) __PYX_ERR(4, 2061, __pyx_L1_error) - - __pyx_codeobj__379 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__343, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMORNINGDOJISTAR, 2099, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__379)) __PYX_ERR(4, 2099, __pyx_L1_error) - - __pyx_codeobj__380 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__343, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMORNINGSTAR, 2137, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__380)) __PYX_ERR(4, 2137, __pyx_L1_error) - - __pyx_codeobj__381 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLONNECK, 2175, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__381)) __PYX_ERR(4, 2175, __pyx_L1_error) - - __pyx_codeobj__382 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLPIERCING, 2211, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__382)) __PYX_ERR(4, 2211, __pyx_L1_error) - - __pyx_codeobj__383 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLRICKSHAWMAN, 2247, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__383)) __PYX_ERR(4, 2247, __pyx_L1_error) - - __pyx_codeobj__384 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLRISEFALL3METHODS, 2283, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__384)) __PYX_ERR(4, 2283, __pyx_L1_error) - - __pyx_codeobj__385 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSEPARATINGLINES, 2319, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__385)) __PYX_ERR(4, 2319, __pyx_L1_error) - - __pyx_codeobj__386 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSHOOTINGSTAR, 2355, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__386)) __PYX_ERR(4, 2355, __pyx_L1_error) - - __pyx_codeobj__387 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSHORTLINE, 2391, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__387)) __PYX_ERR(4, 2391, __pyx_L1_error) - - __pyx_codeobj__388 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSPINNINGTOP, 2427, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__388)) __PYX_ERR(4, 2427, __pyx_L1_error) - - __pyx_codeobj__389 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSTALLEDPATTERN, 2463, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__389)) __PYX_ERR(4, 2463, __pyx_L1_error) - - __pyx_codeobj__390 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSTICKSANDWICH, 2499, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__390)) __PYX_ERR(4, 2499, __pyx_L1_error) - - __pyx_codeobj__391 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLTAKURI, 2535, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__391)) __PYX_ERR(4, 2535, __pyx_L1_error) - - __pyx_codeobj__392 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLTASUKIGAP, 2571, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__392)) __PYX_ERR(4, 2571, __pyx_L1_error) - - __pyx_codeobj__393 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLTHRUSTING, 2607, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__393)) __PYX_ERR(4, 2607, __pyx_L1_error) - - __pyx_codeobj__394 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLTRISTAR, 2643, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__394)) __PYX_ERR(4, 2643, __pyx_L1_error) - - __pyx_codeobj__395 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLUNIQUE3RIVER, 2679, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__395)) __PYX_ERR(4, 2679, __pyx_L1_error) - - __pyx_codeobj__396 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLUPSIDEGAP2CROWS, 2715, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__396)) __PYX_ERR(4, 2715, __pyx_L1_error) - - __pyx_codeobj__397 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLXSIDEGAP3METHODS, 2751, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__397)) __PYX_ERR(4, 2751, __pyx_L1_error) - - __pyx_codeobj__398 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CEIL, 2787, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__398)) __PYX_ERR(4, 2787, __pyx_L1_error) - - __pyx_tuple__399 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__399)) __PYX_ERR(4, 2814, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__399); - __Pyx_GIVEREF(__pyx_tuple__399); - __pyx_codeobj__400 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CMO, 2814, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__400)) __PYX_ERR(4, 2814, __pyx_L1_error) - - __pyx_codeobj__401 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__331, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CORREL, 2843, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__401)) __PYX_ERR(4, 2843, __pyx_L1_error) - - __pyx_codeobj__402 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_COS, 2876, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__402)) __PYX_ERR(4, 2876, __pyx_L1_error) - - __pyx_codeobj__403 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_COSH, 2903, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__403)) __PYX_ERR(4, 2903, __pyx_L1_error) - - __pyx_codeobj__404 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_DEMA, 2930, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__404)) __PYX_ERR(4, 2930, __pyx_L1_error) - - __pyx_codeobj__405 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__311, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_DIV, 2959, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__405)) __PYX_ERR(4, 2959, __pyx_L1_error) - - __pyx_codeobj__406 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_DX, 2990, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__406)) __PYX_ERR(4, 2990, __pyx_L1_error) - - __pyx_codeobj__407 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_EMA, 3025, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__407)) __PYX_ERR(4, 3025, __pyx_L1_error) - - __pyx_codeobj__408 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_EXP, 3054, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__408)) __PYX_ERR(4, 3054, __pyx_L1_error) - - __pyx_codeobj__409 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_FLOOR, 3081, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__409)) __PYX_ERR(4, 3081, __pyx_L1_error) - - __pyx_codeobj__410 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_DCPERIOD, 3108, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__410)) __PYX_ERR(4, 3108, __pyx_L1_error) - - __pyx_codeobj__411 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_DCPHASE, 3135, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__411)) __PYX_ERR(4, 3135, __pyx_L1_error) - - __pyx_tuple__412 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinphase, __pyx_n_s_outquadrature); if (unlikely(!__pyx_tuple__412)) __PYX_ERR(4, 3162, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__412); - __Pyx_GIVEREF(__pyx_tuple__412); - __pyx_codeobj__413 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__412, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_PHASOR, 3162, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__413)) __PYX_ERR(4, 3162, __pyx_L1_error) - - __pyx_tuple__414 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outsine, __pyx_n_s_outleadsine); if (unlikely(!__pyx_tuple__414)) __PYX_ERR(4, 3192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__414); - __Pyx_GIVEREF(__pyx_tuple__414); - __pyx_codeobj__415 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__414, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_SINE, 3192, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__415)) __PYX_ERR(4, 3192, __pyx_L1_error) - - __pyx_codeobj__416 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_TRENDLINE, 3222, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__416)) __PYX_ERR(4, 3222, __pyx_L1_error) - - __pyx_tuple__417 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__417)) __PYX_ERR(4, 3249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__417); - __Pyx_GIVEREF(__pyx_tuple__417); - __pyx_codeobj__418 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__417, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_TRENDMODE, 3249, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__418)) __PYX_ERR(4, 3249, __pyx_L1_error) - - __pyx_codeobj__419 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_KAMA, 3276, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__419)) __PYX_ERR(4, 3276, __pyx_L1_error) - - __pyx_codeobj__420 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LINEARREG, 3305, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__420)) __PYX_ERR(4, 3305, __pyx_L1_error) - - __pyx_codeobj__421 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LINEARREG_ANGLE, 3334, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__421)) __PYX_ERR(4, 3334, __pyx_L1_error) - - __pyx_codeobj__422 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LINEARREG_INTERCEPT, 3363, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__422)) __PYX_ERR(4, 3363, __pyx_L1_error) - - __pyx_codeobj__423 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LINEARREG_SLOPE, 3392, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__423)) __PYX_ERR(4, 3392, __pyx_L1_error) - - __pyx_codeobj__424 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LN, 3421, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__424)) __PYX_ERR(4, 3421, __pyx_L1_error) - - __pyx_codeobj__425 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LOG10, 3448, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__425)) __PYX_ERR(4, 3448, __pyx_L1_error) - - __pyx_tuple__426 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__426)) __PYX_ERR(4, 3475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__426); - __Pyx_GIVEREF(__pyx_tuple__426); - __pyx_codeobj__427 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__426, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MA, 3475, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__427)) __PYX_ERR(4, 3475, __pyx_L1_error) - - __pyx_tuple__428 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_signalperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__428)) __PYX_ERR(4, 3505, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__428); - __Pyx_GIVEREF(__pyx_tuple__428); - __pyx_codeobj__429 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__428, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MACD, 3505, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__429)) __PYX_ERR(4, 3505, __pyx_L1_error) - - __pyx_tuple__430 = PyTuple_Pack(15, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_fastmatype, __pyx_n_s_slowperiod, __pyx_n_s_slowmatype, __pyx_n_s_signalperiod, __pyx_n_s_signalmatype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__430)) __PYX_ERR(4, 3542, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__430); - __Pyx_GIVEREF(__pyx_tuple__430); - __pyx_codeobj__431 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__430, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MACDEXT, 3542, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__431)) __PYX_ERR(4, 3542, __pyx_L1_error) - - __pyx_tuple__432 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_signalperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__432)) __PYX_ERR(4, 3582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__432); - __Pyx_GIVEREF(__pyx_tuple__432); - __pyx_codeobj__433 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__432, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MACDFIX, 3582, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__433)) __PYX_ERR(4, 3582, __pyx_L1_error) - - __pyx_tuple__434 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_fastlimit, __pyx_n_s_slowlimit, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmama, __pyx_n_s_outfama); if (unlikely(!__pyx_tuple__434)) __PYX_ERR(4, 3617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__434); - __Pyx_GIVEREF(__pyx_tuple__434); - __pyx_codeobj__435 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__434, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MAMA, 3617, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__435)) __PYX_ERR(4, 3617, __pyx_L1_error) - - __pyx_tuple__436 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_periods, __pyx_n_s_minperiod, __pyx_n_s_maxperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_periods_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__436)) __PYX_ERR(4, 3650, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__436); - __Pyx_GIVEREF(__pyx_tuple__436); - __pyx_codeobj__437 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__436, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MAVP, 3650, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__437)) __PYX_ERR(4, 3650, __pyx_L1_error) - - __pyx_codeobj__438 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MAX, 3685, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__438)) __PYX_ERR(4, 3685, __pyx_L1_error) - - __pyx_tuple__439 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__439)) __PYX_ERR(4, 3714, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__439); - __Pyx_GIVEREF(__pyx_tuple__439); - __pyx_codeobj__440 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__439, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MAXINDEX, 3714, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__440)) __PYX_ERR(4, 3714, __pyx_L1_error) - - __pyx_tuple__441 = PyTuple_Pack(9, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__441)) __PYX_ERR(4, 3743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__441); - __Pyx_GIVEREF(__pyx_tuple__441); - __pyx_codeobj__442 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__441, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MEDPRICE, 3743, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__442)) __PYX_ERR(4, 3743, __pyx_L1_error) - - __pyx_tuple__443 = PyTuple_Pack(14, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_volume_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__443)) __PYX_ERR(4, 3773, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__443); - __Pyx_GIVEREF(__pyx_tuple__443); - __pyx_codeobj__444 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__443, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MFI, 3773, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__444)) __PYX_ERR(4, 3773, __pyx_L1_error) - - __pyx_codeobj__445 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MIDPOINT, 3811, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__445)) __PYX_ERR(4, 3811, __pyx_L1_error) - - __pyx_codeobj__446 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__322, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MIDPRICE, 3840, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__446)) __PYX_ERR(4, 3840, __pyx_L1_error) - - __pyx_codeobj__447 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MIN, 3872, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__447)) __PYX_ERR(4, 3872, __pyx_L1_error) - - __pyx_codeobj__448 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__439, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MININDEX, 3901, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__448)) __PYX_ERR(4, 3901, __pyx_L1_error) - - __pyx_tuple__449 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmin, __pyx_n_s_outmax); if (unlikely(!__pyx_tuple__449)) __PYX_ERR(4, 3930, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__449); - __Pyx_GIVEREF(__pyx_tuple__449); - __pyx_codeobj__450 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__449, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MINMAX, 3930, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__450)) __PYX_ERR(4, 3930, __pyx_L1_error) - - __pyx_tuple__451 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outminidx, __pyx_n_s_outmaxidx); if (unlikely(!__pyx_tuple__451)) __PYX_ERR(4, 3962, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__451); - __Pyx_GIVEREF(__pyx_tuple__451); - __pyx_codeobj__452 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__451, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MINMAXINDEX, 3962, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__452)) __PYX_ERR(4, 3962, __pyx_L1_error) - - __pyx_codeobj__453 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MINUS_DI, 3994, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__453)) __PYX_ERR(4, 3994, __pyx_L1_error) - - __pyx_codeobj__454 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__322, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MINUS_DM, 4029, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__454)) __PYX_ERR(4, 4029, __pyx_L1_error) - - __pyx_codeobj__455 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MOM, 4061, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__455)) __PYX_ERR(4, 4061, __pyx_L1_error) - - __pyx_codeobj__456 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__311, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MULT, 4090, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__456)) __PYX_ERR(4, 4090, __pyx_L1_error) - - __pyx_codeobj__457 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_NATR, 4121, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__457)) __PYX_ERR(4, 4121, __pyx_L1_error) - - __pyx_tuple__458 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_volume, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_volume_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__458)) __PYX_ERR(4, 4156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__458); - __Pyx_GIVEREF(__pyx_tuple__458); - __pyx_codeobj__459 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__458, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_OBV, 4156, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__459)) __PYX_ERR(4, 4156, __pyx_L1_error) - - __pyx_codeobj__460 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_PLUS_DI, 4187, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__460)) __PYX_ERR(4, 4187, __pyx_L1_error) - - __pyx_codeobj__461 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__322, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_PLUS_DM, 4222, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__461)) __PYX_ERR(4, 4222, __pyx_L1_error) - - __pyx_codeobj__462 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__318, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_PPO, 4254, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__462)) __PYX_ERR(4, 4254, __pyx_L1_error) - - __pyx_codeobj__463 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ROC, 4285, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__463)) __PYX_ERR(4, 4285, __pyx_L1_error) - - __pyx_codeobj__464 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ROCP, 4314, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__464)) __PYX_ERR(4, 4314, __pyx_L1_error) - - __pyx_codeobj__465 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ROCR, 4343, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__465)) __PYX_ERR(4, 4343, __pyx_L1_error) - - __pyx_codeobj__466 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ROCR100, 4372, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__466)) __PYX_ERR(4, 4372, __pyx_L1_error) - - __pyx_codeobj__467 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_RSI, 4401, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__467)) __PYX_ERR(4, 4401, __pyx_L1_error) - - __pyx_tuple__468 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_acceleration, __pyx_n_s_maximum, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__468)) __PYX_ERR(4, 4430, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__468); - __Pyx_GIVEREF(__pyx_tuple__468); - __pyx_codeobj__469 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__468, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SAR, 4430, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__469)) __PYX_ERR(4, 4430, __pyx_L1_error) - - __pyx_tuple__470 = PyTuple_Pack(17, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_startvalue, __pyx_n_s_offsetonreverse, __pyx_n_s_accelerationinitlong, __pyx_n_s_accelerationlong, __pyx_n_s_accelerationmaxlong, __pyx_n_s_accelerationinitshort, __pyx_n_s_accelerationshort, __pyx_n_s_accelerationmaxshort, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__470)) __PYX_ERR(4, 4463, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__470); - __Pyx_GIVEREF(__pyx_tuple__470); - __pyx_codeobj__471 = (PyObject*)__Pyx_PyCode_New(10, 0, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__470, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SAREXT, 4463, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__471)) __PYX_ERR(4, 4463, __pyx_L1_error) - - __pyx_codeobj__472 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SIN, 4502, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__472)) __PYX_ERR(4, 4502, __pyx_L1_error) - - __pyx_codeobj__473 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SINH, 4529, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__473)) __PYX_ERR(4, 4529, __pyx_L1_error) - - __pyx_codeobj__474 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SMA, 4556, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__474)) __PYX_ERR(4, 4556, __pyx_L1_error) - - __pyx_codeobj__475 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SQRT, 4585, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__475)) __PYX_ERR(4, 4585, __pyx_L1_error) - - __pyx_tuple__476 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdev, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__476)) __PYX_ERR(4, 4612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__476); - __Pyx_GIVEREF(__pyx_tuple__476); - __pyx_codeobj__477 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__476, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_STDDEV, 4612, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__477)) __PYX_ERR(4, 4612, __pyx_L1_error) - - __pyx_tuple__478 = PyTuple_Pack(17, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_fastk_period, __pyx_n_s_slowk_period, __pyx_n_s_slowk_matype, __pyx_n_s_slowd_period, __pyx_n_s_slowd_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outslowk, __pyx_n_s_outslowd); if (unlikely(!__pyx_tuple__478)) __PYX_ERR(4, 4642, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__478); - __Pyx_GIVEREF(__pyx_tuple__478); - __pyx_codeobj__479 = (PyObject*)__Pyx_PyCode_New(8, 0, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__478, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_STOCH, 4642, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__479)) __PYX_ERR(4, 4642, __pyx_L1_error) - - __pyx_tuple__480 = PyTuple_Pack(15, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_fastk_period, __pyx_n_s_fastd_period, __pyx_n_s_fastd_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outfastk, __pyx_n_s_outfastd); if (unlikely(!__pyx_tuple__480)) __PYX_ERR(4, 4684, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__480); - __Pyx_GIVEREF(__pyx_tuple__480); - __pyx_codeobj__481 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__480, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_STOCHF, 4684, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__481)) __PYX_ERR(4, 4684, __pyx_L1_error) - - __pyx_tuple__482 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_fastk_period, __pyx_n_s_fastd_period, __pyx_n_s_fastd_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outfastk, __pyx_n_s_outfastd); if (unlikely(!__pyx_tuple__482)) __PYX_ERR(4, 4724, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__482); - __Pyx_GIVEREF(__pyx_tuple__482); - __pyx_codeobj__483 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__482, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_STOCHRSI, 4724, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__483)) __PYX_ERR(4, 4724, __pyx_L1_error) - - __pyx_codeobj__484 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__311, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SUB, 4759, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__484)) __PYX_ERR(4, 4759, __pyx_L1_error) - - __pyx_codeobj__485 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SUM, 4790, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__485)) __PYX_ERR(4, 4790, __pyx_L1_error) - - __pyx_tuple__486 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_vfactor, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__486)) __PYX_ERR(4, 4819, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__486); - __Pyx_GIVEREF(__pyx_tuple__486); - __pyx_codeobj__487 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__486, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_T3, 4819, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__487)) __PYX_ERR(4, 4819, __pyx_L1_error) - - __pyx_codeobj__488 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TAN, 4849, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__488)) __PYX_ERR(4, 4849, __pyx_L1_error) - - __pyx_codeobj__489 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TANH, 4876, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__489)) __PYX_ERR(4, 4876, __pyx_L1_error) - - __pyx_codeobj__490 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TEMA, 4903, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__490)) __PYX_ERR(4, 4903, __pyx_L1_error) - - __pyx_tuple__491 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__491)) __PYX_ERR(4, 4932, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__491); - __Pyx_GIVEREF(__pyx_tuple__491); - __pyx_codeobj__492 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__491, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TRANGE, 4932, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__492)) __PYX_ERR(4, 4932, __pyx_L1_error) - - __pyx_codeobj__493 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TRIMA, 4965, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__493)) __PYX_ERR(4, 4965, __pyx_L1_error) - - __pyx_codeobj__494 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TRIX, 4994, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__494)) __PYX_ERR(4, 4994, __pyx_L1_error) - - __pyx_codeobj__495 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TSF, 5023, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__495)) __PYX_ERR(4, 5023, __pyx_L1_error) - - __pyx_codeobj__496 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__491, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TYPPRICE, 5052, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__496)) __PYX_ERR(4, 5052, __pyx_L1_error) - - __pyx_tuple__497 = PyTuple_Pack(14, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod1, __pyx_n_s_timeperiod2, __pyx_n_s_timeperiod3, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__497)) __PYX_ERR(4, 5085, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__497); - __Pyx_GIVEREF(__pyx_tuple__497); - __pyx_codeobj__498 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__497, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ULTOSC, 5085, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__498)) __PYX_ERR(4, 5085, __pyx_L1_error) - - __pyx_codeobj__499 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__476, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_VAR, 5122, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__499)) __PYX_ERR(4, 5122, __pyx_L1_error) - - __pyx_codeobj__500 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__491, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_WCLPRICE, 5152, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__500)) __PYX_ERR(4, 5152, __pyx_L1_error) - - __pyx_codeobj__501 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_WILLR, 5185, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__501)) __PYX_ERR(4, 5185, __pyx_L1_error) - - __pyx_codeobj__502 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_WMA, 5220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__502)) __PYX_ERR(4, 5220, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} -/* #### Code section: init_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { - __pyx_umethod_PyDict_Type_keys.type = (PyObject*)&PyDict_Type; - __pyx_umethod_PyDict_Type_keys.method_name = &__pyx_n_s_keys; - if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(5, 1, __pyx_L1_error); - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_8 = PyInt_FromLong(8); if (unlikely(!__pyx_int_8)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_9 = PyInt_FromLong(9); if (unlikely(!__pyx_int_9)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_12 = PyInt_FromLong(12); if (unlikely(!__pyx_int_12)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_16 = PyInt_FromLong(16); if (unlikely(!__pyx_int_16)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_32 = PyInt_FromLong(32); if (unlikely(!__pyx_int_32)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_64 = PyInt_FromLong(64); if (unlikely(!__pyx_int_64)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_128 = PyInt_FromLong(128); if (unlikely(!__pyx_int_128)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_256 = PyInt_FromLong(256); if (unlikely(!__pyx_int_256)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_512 = PyInt_FromLong(512); if (unlikely(!__pyx_int_512)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_1024 = PyInt_FromLong(1024); if (unlikely(!__pyx_int_1024)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_2048 = PyInt_FromLong(2048); if (unlikely(!__pyx_int_2048)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_4096 = PyInt_FromLong(4096); if (unlikely(!__pyx_int_4096)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_16777216 = PyInt_FromLong(16777216L); if (unlikely(!__pyx_int_16777216)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_67108864 = PyInt_FromLong(67108864L); if (unlikely(!__pyx_int_67108864)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_134217728 = PyInt_FromLong(134217728L); if (unlikely(!__pyx_int_134217728)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_268435456 = PyInt_FromLong(268435456L); if (unlikely(!__pyx_int_268435456)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(5, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_globals ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - return 0; -} +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ /* #### Code section: init_module ### */ -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { +static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_variable_export_code(void) { +static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_function_export_code(void) { +static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_type_init_code(void) { +static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_type_import_code(void) { +static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; @@ -95970,33 +80568,153 @@ static int __Pyx_modinit_type_import_code(void) { /*--- 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_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_2_4(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyTypeObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + 0, 0, #else - sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyHeapTypeObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_ImportType_CheckSize_Warn_3_2_4); 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(2, 202, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArray_Descr),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(2, 202, __pyx_L1_error) - __pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArrayIterObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(2, 225, __pyx_L1_error) - __pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArrayMultiIterObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(2, 229, __pyx_L1_error) - __pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArrayObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(2, 238, __pyx_L1_error) - __pyx_ptype_5numpy_generic = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_generic) __PYX_ERR(2, 809, __pyx_L1_error) - __pyx_ptype_5numpy_number = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "number", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_number) __PYX_ERR(2, 811, __pyx_L1_error) - __pyx_ptype_5numpy_integer = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_integer) __PYX_ERR(2, 813, __pyx_L1_error) - __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(2, 815, __pyx_L1_error) - __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(2, 817, __pyx_L1_error) - __pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(2, 819, __pyx_L1_error) - __pyx_ptype_5numpy_floating = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_floating) __PYX_ERR(2, 821, __pyx_L1_error) - __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(2, 823, __pyx_L1_error) - __pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(2, 825, __pyx_L1_error) - __pyx_ptype_5numpy_character = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "character", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_character) __PYX_ERR(2, 827, __pyx_L1_error) - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyUFuncObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(2, 866, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "dtype", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArray_Descr), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArray_Descr), + #else + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArray_Descr), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_dtype) __PYX_ERR(3, 271, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "flatiter", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArrayIterObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArrayIterObject), + #else + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArrayIterObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_flatiter) __PYX_ERR(3, 316, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "broadcast", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArrayMultiIterObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArrayMultiIterObject), + #else + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArrayMultiIterObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_broadcast) __PYX_ERR(3, 320, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "ndarray", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArrayObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArrayObject), + #else + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyArrayObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_ndarray) __PYX_ERR(3, 359, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_generic = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "generic", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_generic) __PYX_ERR(3, 864, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_number = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "number", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_number) __PYX_ERR(3, 866, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_integer = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "integer", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_integer) __PYX_ERR(3, 868, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "signedinteger", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_signedinteger) __PYX_ERR(3, 870, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "unsignedinteger", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(3, 872, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "inexact", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_inexact) __PYX_ERR(3, 874, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_floating = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "floating", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_floating) __PYX_ERR(3, 876, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "complexfloating", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_complexfloating) __PYX_ERR(3, 878, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "flexible", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_flexible) __PYX_ERR(3, 880, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_character = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "character", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_4); if (!__pyx_mstate->__pyx_ptype_5numpy_character) __PYX_ERR(3, 882, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_2_4(__pyx_t_1, "numpy", "ufunc", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyUFuncObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyUFuncObject), + #else + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyUFuncObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_4); 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; @@ -96006,30 +80724,36 @@ static int __Pyx_modinit_type_import_code(void) { return -1; } -static int __Pyx_modinit_variable_import_code(void) { +static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } -static int __Pyx_modinit_function_import_code(void) { +static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) { __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } - -#if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec__ta_lib(PyObject* module); /*proto*/ 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, __Pyx_FREETHREADING_COMPATIBLE}, + #endif + #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE + {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, + #endif {0, NULL} }; #endif @@ -96044,12 +80768,10 @@ namespace { PyModuleDef_HEAD_INIT, "_ta_lib", 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #elif CYTHON_USE_MODULE_STATE - sizeof(__pyx_mstate), /* m_size */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ #else - -1, /* m_size */ + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT @@ -96070,51 +80792,75 @@ namespace { #ifdef __cplusplus } /* anonymous namespace */ #endif -#endif +/* PyModInitFuncType */ #ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif #endif - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC init_ta_lib(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC init_ta_lib(void) -#else __Pyx_PyMODINIT_FUNC PyInit__ta_lib(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit__ta_lib(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } +/* ModuleCreationPEP489 */ +#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 + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; +#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\ + || ((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 + if (unlikely(current_id == -1)) { + return -1; + } if (main_interpreter_id == -1) { main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); @@ -96122,21 +80868,14 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) -#else -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) #endif +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { -#if CYTHON_COMPILING_IN_LIMITED_API - result = PyModule_AddObject(module, to_name, value); -#else result = PyDict_SetItemString(moddict, to_name, value); -#endif } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { @@ -96149,8 +80888,10 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; CYTHON_UNUSED_VAR(def); + #if !CYTHON_USE_MODULE_STATE if (__Pyx_check_single_interpreter()) return NULL; + #endif if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); @@ -96158,12 +80899,8 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDe module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; -#if CYTHON_COMPILING_IN_LIMITED_API - moddict = module; -#else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; -#endif if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; @@ -96177,19 +80914,19 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDe static CYTHON_SMALL_CODE int __pyx_pymod_exec__ta_lib(PyObject *__pyx_pyinit_module) #endif -#endif { int stringtab_initialized = 0; #if CYTHON_USE_MODULE_STATE int pystate_addmodule_run = 0; #endif + __pyx_mstatetype *__pyx_mstate = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; @@ -96198,18 +80935,24 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec__ta_lib(PyObject *__pyx_pyinit_mod PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; - PyObject *(*__pyx_t_16)(PyObject *); - Py_ssize_t __pyx_t_17; - PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *(*__pyx_t_17)(PyObject *); + Py_ssize_t __pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; - double __pyx_t_21; - int __pyx_t_22; - PyObject *__pyx_t_23 = NULL; + PyObject *__pyx_t_21 = NULL; + double __pyx_t_22; + int __pyx_t_23; PyObject *__pyx_t_24 = NULL; - int __pyx_t_25; - int __pyx_t_26; - PyObject *(*__pyx_t_27)(PyObject *); + PyObject *__pyx_t_25 = NULL; + PyObject *__pyx_t_26 = NULL; + int __pyx_t_27; + PyObject *__pyx_t_28 = NULL; + PyObject *__pyx_t_29 = NULL; + int __pyx_t_30; + int __pyx_t_31; + int __pyx_t_32; + PyObject *(*__pyx_t_33)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -96220,2877 +80963,2549 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec__ta_lib(PyObject *__pyx_pyinit_mod PyErr_SetString(PyExc_RuntimeError, "Module '_ta_lib' has already been imported. Re-initialisation is not supported."); return -1; } - #elif PY_MAJOR_VERSION >= 3 + #else if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); + __pyx_t_1 = __pyx_pyinit_module; + Py_INCREF(__pyx_t_1); #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("_ta_lib", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - if (unlikely(!__pyx_m)) __PYX_ERR(5, 1, __pyx_L1_error) - #elif CYTHON_USE_MODULE_STATE - __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if CYTHON_USE_MODULE_STATE { - int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "_ta_lib" pseudovariable */ - if (unlikely((add_module_result < 0))) __PYX_ERR(5, 1, __pyx_L1_error) + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) pystate_addmodule_run = 1; } #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - if (unlikely(!__pyx_m)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_m = __pyx_t_1; #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_USED); #endif + __pyx_mstate = __pyx_mstate_global; CYTHON_UNUSED_VAR(__pyx_t_1); - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(5, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(5, 1, __pyx_L1_error) - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_mstate->__pyx_d); + __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + 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("__Pyx_PyMODINIT_FUNC PyInit__ta_lib(void)", 0); - if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(5, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(5, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(5, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) - #endif + __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) /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitConstants() < 0) __PYX_ERR(5, 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(5, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(5, 1, __pyx_L1_error) - #endif + 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_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(5, 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) } - #if PY_MAJOR_VERSION >= 3 { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(5, 1, __pyx_L1_error) + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "talib._ta_lib")) { - if (unlikely((PyDict_SetItemString(modules, "talib._ta_lib", __pyx_m) < 0))) __PYX_ERR(5, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "talib._ta_lib", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } - #endif /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(5, 1, __pyx_L1_error) + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(5, 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(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - (void)__Pyx_modinit_type_init_code(); - if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(5, 1, __pyx_L1_error) - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); + (void)__Pyx_modinit_global_init_code(__pyx_mstate); + (void)__Pyx_modinit_variable_export_code(__pyx_mstate); + (void)__Pyx_modinit_function_export_code(__pyx_mstate); + (void)__Pyx_modinit_type_init_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_type_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(__pyx_mstate); + (void)__Pyx_modinit_function_import_code(__pyx_mstate); /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(5, 1, __pyx_L1_error) - #endif - __pyx_t_2 = __Pyx_PyBytes_FromString(TA_GetVersionString()); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __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_d, __pyx_n_s_ta_version, __pyx_t_2) < 0) __PYX_ERR(0, 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_n_s_ta_check_success, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __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_d, __pyx_n_s_ta_check_success, __pyx_t_2) < 0) __PYX_ERR(0, 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_n_s_ta_initialize, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) + __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_d, __pyx_n_s_ta_initialize, __pyx_t_2) < 0) __PYX_ERR(0, 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_n_s_ta_shutdown, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error) + __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_d, __pyx_n_s_ta_shutdown, __pyx_t_2) < 0) __PYX_ERR(0, 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_tuple__19); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) + __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) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_2, __pyx_n_s_MA_Type, __pyx_n_s_MA_Type, (PyObject *) NULL, __pyx_n_s_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 60, __pyx_L1_error) + __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_mstate_global->__pyx_n_u_MA_Type, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (__pyx_t_2 != __pyx_tuple__19) { - if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_tuple__19) < 0))) __PYX_ERR(0, 60, __pyx_L1_error) + if (__pyx_t_2 != __pyx_mstate_global->__pyx_tuple[2]) { + if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[2]) < 0))) __PYX_ERR(1, 60, __pyx_L1_error) } - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 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(0, 61, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); - __pyx_t_8 = PyTuple_GET_ITEM(sequence, 2); - __pyx_t_9 = PyTuple_GET_ITEM(sequence, 3); - __pyx_t_10 = PyTuple_GET_ITEM(sequence, 4); - __pyx_t_11 = PyTuple_GET_ITEM(sequence, 5); - __pyx_t_12 = PyTuple_GET_ITEM(sequence, 6); - __pyx_t_13 = PyTuple_GET_ITEM(sequence, 7); - __pyx_t_14 = PyTuple_GET_ITEM(sequence, 8); - } else { - __pyx_t_6 = PyList_GET_ITEM(sequence, 0); - __pyx_t_7 = PyList_GET_ITEM(sequence, 1); - __pyx_t_8 = PyList_GET_ITEM(sequence, 2); - __pyx_t_9 = PyList_GET_ITEM(sequence, 3); - __pyx_t_10 = PyList_GET_ITEM(sequence, 4); - __pyx_t_11 = PyList_GET_ITEM(sequence, 5); - __pyx_t_12 = PyList_GET_ITEM(sequence, 6); - __pyx_t_13 = PyList_GET_ITEM(sequence, 7); - __pyx_t_14 = PyList_GET_ITEM(sequence, 8); - } - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(__pyx_t_11); - __Pyx_INCREF(__pyx_t_12); - __Pyx_INCREF(__pyx_t_13); - __Pyx_INCREF(__pyx_t_14); - #else - { - Py_ssize_t i; - PyObject** temps[9] = {&__pyx_t_6,&__pyx_t_7,&__pyx_t_8,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14}; - for (i=0; i < 9; i++) { - PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(item); - *(temps[i]) = item; - } - } - #endif - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } else { + __pyx_t_6 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_9}; + __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; + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + { Py_ssize_t index = -1; - PyObject** temps[9] = {&__pyx_t_6,&__pyx_t_7,&__pyx_t_8,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14}; - __pyx_t_15 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(__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; - __pyx_t_16 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_15); + __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_16); for (index=0; index < 9; index++) { - PyObject* item = __pyx_t_16(__pyx_t_15); if (unlikely(!item)) goto __pyx_L2_unpacking_failed; + PyObject* item = __pyx_t_17(__pyx_t_16); if (unlikely(!item)) goto __pyx_L2_unpacking_failed; __Pyx_GOTREF(item); *(temps[index]) = item; } - if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_15), 9) < 0) __PYX_ERR(0, 61, __pyx_L1_error) - __pyx_t_16 = NULL; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + 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; __pyx_L2_unpacking_failed:; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_17 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 61, __pyx_L1_error) + __PYX_ERR(1, 61, __pyx_L1_error) __pyx_L3_unpacking_done:; } - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_n_s_SMA, __pyx_t_6) < 0) __PYX_ERR(0, 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_n_s_EMA, __pyx_t_7) < 0) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_n_s_WMA, __pyx_t_8) < 0) __PYX_ERR(0, 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_n_s_DEMA, __pyx_t_9) < 0) __PYX_ERR(0, 61, __pyx_L1_error) + 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_n_s_TEMA, __pyx_t_10) < 0) __PYX_ERR(0, 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_n_s_TRIMA, __pyx_t_11) < 0) __PYX_ERR(0, 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_n_s_KAMA, __pyx_t_12) < 0) __PYX_ERR(0, 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_n_s_MAMA, __pyx_t_13) < 0) __PYX_ERR(0, 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_n_s_T3, __pyx_t_14) < 0) __PYX_ERR(0, 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) + __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_n_s_MA_Type___init, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 63, __pyx_L1_error) + __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_n_s_init, __pyx_t_5) < 0) __PYX_ERR(0, 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_n_s_MA_Type___getitem, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error) + __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_n_s_getitem, __pyx_t_5) < 0) __PYX_ERR(0, 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_n_s_MA_Type, __pyx_t_2, __pyx_t_4, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error) + __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_d, __pyx_n_s_MA_Type, __pyx_t_5) < 0) __PYX_ERR(0, 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; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __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_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __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) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MA_Type, __pyx_t_3) < 0) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_NONE, __pyx_int_neg_1) < 0) __PYX_ERR(0, 81, __pyx_L1_error) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_func_unst_ids, __pyx_t_3) < 0) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_INCREF(__pyx_int_0); - __pyx_t_3 = __pyx_int_0; - __pyx_t_2 = PyList_New(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_ADX); - __Pyx_GIVEREF(__pyx_n_s_ADX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_ADX)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ADXR); - __Pyx_GIVEREF(__pyx_n_s_ADXR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_ADXR)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ATR); - __Pyx_GIVEREF(__pyx_n_s_ATR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_ATR)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CMO); - __Pyx_GIVEREF(__pyx_n_s_CMO); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_CMO)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_DX); - __Pyx_GIVEREF(__pyx_n_s_DX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 4, __pyx_n_s_DX)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_EMA); - __Pyx_GIVEREF(__pyx_n_s_EMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 5, __pyx_n_s_EMA)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_DCPERIOD); - __Pyx_GIVEREF(__pyx_n_s_HT_DCPERIOD); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 6, __pyx_n_s_HT_DCPERIOD)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_DCPHASE); - __Pyx_GIVEREF(__pyx_n_s_HT_DCPHASE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 7, __pyx_n_s_HT_DCPHASE)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_PHASOR); - __Pyx_GIVEREF(__pyx_n_s_HT_PHASOR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 8, __pyx_n_s_HT_PHASOR)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_SINE); - __Pyx_GIVEREF(__pyx_n_s_HT_SINE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 9, __pyx_n_s_HT_SINE)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_TRENDLINE); - __Pyx_GIVEREF(__pyx_n_s_HT_TRENDLINE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 10, __pyx_n_s_HT_TRENDLINE)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_TRENDMODE); - __Pyx_GIVEREF(__pyx_n_s_HT_TRENDMODE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 11, __pyx_n_s_HT_TRENDMODE)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_KAMA); - __Pyx_GIVEREF(__pyx_n_s_KAMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 12, __pyx_n_s_KAMA)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MAMA); - __Pyx_GIVEREF(__pyx_n_s_MAMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 13, __pyx_n_s_MAMA)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MFI); - __Pyx_GIVEREF(__pyx_n_s_MFI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 14, __pyx_n_s_MFI)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MINUS_DI); - __Pyx_GIVEREF(__pyx_n_s_MINUS_DI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 15, __pyx_n_s_MINUS_DI)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MINUS_DM); - __Pyx_GIVEREF(__pyx_n_s_MINUS_DM); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 16, __pyx_n_s_MINUS_DM)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_NATR); - __Pyx_GIVEREF(__pyx_n_s_NATR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 17, __pyx_n_s_NATR)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_PLUS_DI); - __Pyx_GIVEREF(__pyx_n_s_PLUS_DI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 18, __pyx_n_s_PLUS_DI)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_PLUS_DM); - __Pyx_GIVEREF(__pyx_n_s_PLUS_DM); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 19, __pyx_n_s_PLUS_DM)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_RSI); - __Pyx_GIVEREF(__pyx_n_s_RSI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 20, __pyx_n_s_RSI)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_STOCHRSI); - __Pyx_GIVEREF(__pyx_n_s_STOCHRSI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 21, __pyx_n_s_STOCHRSI)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_T3); - __Pyx_GIVEREF(__pyx_n_s_T3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 22, __pyx_n_s_T3)) __PYX_ERR(0, 82, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ALL); - __Pyx_GIVEREF(__pyx_n_s_ALL); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 23, __pyx_n_s_ALL)) __PYX_ERR(0, 82, __pyx_L1_error); - __pyx_t_4 = __pyx_t_2; __Pyx_INCREF(__pyx_t_4); - __pyx_t_17 = 0; + 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); + __pyx_t_2 = __pyx_mstate_global->__pyx_int_0; + __pyx_t_4 = __Pyx_PyList_Pack(24, __pyx_mstate_global->__pyx_n_u_ADX, __pyx_mstate_global->__pyx_n_u_ADXR, __pyx_mstate_global->__pyx_n_u_ATR, __pyx_mstate_global->__pyx_n_u_CMO, __pyx_mstate_global->__pyx_n_u_DX, __pyx_mstate_global->__pyx_n_u_EMA, __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_KAMA, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_mstate_global->__pyx_n_u_MFI, __pyx_mstate_global->__pyx_n_u_MINUS_DI, __pyx_mstate_global->__pyx_n_u_MINUS_DM, __pyx_mstate_global->__pyx_n_u_NATR, __pyx_mstate_global->__pyx_n_u_PLUS_DI, __pyx_mstate_global->__pyx_n_u_PLUS_DM, __pyx_mstate_global->__pyx_n_u_RSI, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_mstate_global->__pyx_n_u_T3, __pyx_mstate_global->__pyx_n_u_ALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; __Pyx_INCREF(__pyx_t_3); + __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; for (;;) { - if (__pyx_t_17 >= 24) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_17); __Pyx_INCREF(__pyx_t_2); __pyx_t_17++; if (unlikely((0 < 0))) __PYX_ERR(0, 82, __pyx_L1_error) - #else - __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_17); __pyx_t_17++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - #endif - if (PyDict_SetItem(__pyx_d, __pyx_n_s_name, __pyx_t_2) < 0) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_i, __pyx_t_3) < 0) __PYX_ERR(0, 82, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); - __pyx_t_3 = __pyx_t_2; - __pyx_t_2 = 0; + if (__pyx_t_18 >= 24) break; + __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) + __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) + __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); + __pyx_t_2 = __pyx_t_4; + __pyx_t_4 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_ta_func_unst_ids); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_n_s_name); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_t_14, __pyx_t_2) < 0))) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_t_15, __pyx_t_4) < 0))) __PYX_ERR(1, 88, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_7_ta_set_unstable_period, 0, __pyx_n_s_ta_set_unstable_period, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_set_unstable_period, __pyx_t_3) < 0) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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 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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_9_ta_get_unstable_period, 0, __pyx_n_s_ta_get_unstable_period, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_get_unstable_period, __pyx_t_3) < 0) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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 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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_11_ta_set_compatibility, 0, __pyx_n_s_ta_set_compatibility, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_set_compatibility, __pyx_t_3) < 0) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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 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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_13_ta_get_compatibility, 0, __pyx_n_s_ta_get_compatibility, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_get_compatibility, __pyx_t_3) < 0) __PYX_ERR(0, 107, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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 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_3 = __Pyx_PEP560_update_bases(__pyx_tuple__34); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error) + __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) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_mstate_global->__pyx_n_u_CandleSettingType, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_CandleSettingType, __pyx_n_s_CandleSettingType, (PyObject *) NULL, __pyx_n_s_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__pyx_t_3 != __pyx_tuple__34) { - if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_tuple__34) < 0))) __PYX_ERR(0, 112, __pyx_L1_error) + if (__pyx_t_2 != __pyx_mstate_global->__pyx_tuple[4]) { + if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[4]) < 0))) __PYX_ERR(1, 112, __pyx_L1_error) } - __pyx_t_14 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 115, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if ((likely(PyTuple_CheckExact(__pyx_t_14))) || (PyList_CheckExact(__pyx_t_14))) { - PyObject* sequence = __pyx_t_14; - 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(0, 113, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_13 = PyTuple_GET_ITEM(sequence, 1); - __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2); - __pyx_t_11 = PyTuple_GET_ITEM(sequence, 3); - __pyx_t_10 = PyTuple_GET_ITEM(sequence, 4); - __pyx_t_9 = PyTuple_GET_ITEM(sequence, 5); - __pyx_t_8 = PyTuple_GET_ITEM(sequence, 6); - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 7); - __pyx_t_6 = PyTuple_GET_ITEM(sequence, 8); - __pyx_t_15 = PyTuple_GET_ITEM(sequence, 9); - __pyx_t_18 = PyTuple_GET_ITEM(sequence, 10); - __pyx_t_19 = PyTuple_GET_ITEM(sequence, 11); - } else { - __pyx_t_5 = PyList_GET_ITEM(sequence, 0); - __pyx_t_13 = PyList_GET_ITEM(sequence, 1); - __pyx_t_12 = PyList_GET_ITEM(sequence, 2); - __pyx_t_11 = PyList_GET_ITEM(sequence, 3); - __pyx_t_10 = PyList_GET_ITEM(sequence, 4); - __pyx_t_9 = PyList_GET_ITEM(sequence, 5); - __pyx_t_8 = PyList_GET_ITEM(sequence, 6); - __pyx_t_7 = PyList_GET_ITEM(sequence, 7); - __pyx_t_6 = PyList_GET_ITEM(sequence, 8); - __pyx_t_15 = PyList_GET_ITEM(sequence, 9); - __pyx_t_18 = PyList_GET_ITEM(sequence, 10); - __pyx_t_19 = PyList_GET_ITEM(sequence, 11); - } - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(__pyx_t_13); - __Pyx_INCREF(__pyx_t_12); - __Pyx_INCREF(__pyx_t_11); - __Pyx_INCREF(__pyx_t_10); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(__pyx_t_15); - __Pyx_INCREF(__pyx_t_18); - __Pyx_INCREF(__pyx_t_19); - #else - { - Py_ssize_t i; - PyObject** temps[12] = {&__pyx_t_5,&__pyx_t_13,&__pyx_t_12,&__pyx_t_11,&__pyx_t_10,&__pyx_t_9,&__pyx_t_8,&__pyx_t_7,&__pyx_t_6,&__pyx_t_15,&__pyx_t_18,&__pyx_t_19}; - for (i=0; i < 12; i++) { - PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(item); - *(temps[i]) = item; - } - } - #endif - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - } else { + __pyx_t_5 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_12}; + __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; + if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + } + { Py_ssize_t index = -1; - PyObject** temps[12] = {&__pyx_t_5,&__pyx_t_13,&__pyx_t_12,&__pyx_t_11,&__pyx_t_10,&__pyx_t_9,&__pyx_t_8,&__pyx_t_7,&__pyx_t_6,&__pyx_t_15,&__pyx_t_18,&__pyx_t_19}; - __pyx_t_20 = PyObject_GetIter(__pyx_t_14); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __pyx_t_16 = __Pyx_PyObject_GetIterNextFunc(__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; + __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_21); for (index=0; index < 12; index++) { - PyObject* item = __pyx_t_16(__pyx_t_20); if (unlikely(!item)) goto __pyx_L7_unpacking_failed; + PyObject* item = __pyx_t_17(__pyx_t_21); if (unlikely(!item)) goto __pyx_L7_unpacking_failed; __Pyx_GOTREF(item); *(temps[index]) = item; } - if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_20), 12) < 0) __PYX_ERR(0, 113, __pyx_L1_error) - __pyx_t_16 = NULL; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + 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; __pyx_L7_unpacking_failed:; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __pyx_t_17 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 113, __pyx_L1_error) + __PYX_ERR(1, 113, __pyx_L1_error) __pyx_L8_unpacking_done:; } - if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_BodyLong, __pyx_t_5) < 0) __PYX_ERR(0, 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_2, __pyx_n_s_BodyVeryLong, __pyx_t_13) < 0) __PYX_ERR(0, 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_2, __pyx_n_s_BodyShort, __pyx_t_12) < 0) __PYX_ERR(0, 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_2, __pyx_n_s_BodyDoji, __pyx_t_11) < 0) __PYX_ERR(0, 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_2, __pyx_n_s_ShadowLong, __pyx_t_10) < 0) __PYX_ERR(0, 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_2, __pyx_n_s_ShadowVeryLong, __pyx_t_9) < 0) __PYX_ERR(0, 113, __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_2, __pyx_n_s_ShadowShort, __pyx_t_8) < 0) __PYX_ERR(0, 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_2, __pyx_n_s_ShadowVeryShort, __pyx_t_7) < 0) __PYX_ERR(0, 114, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_Near, __pyx_t_6) < 0) __PYX_ERR(0, 114, __pyx_L1_error) + 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_2, __pyx_n_s_Far, __pyx_t_15) < 0) __PYX_ERR(0, 114, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_Equal, __pyx_t_18) < 0) __PYX_ERR(0, 114, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_AllCandleSettings, __pyx_t_19) < 0) __PYX_ERR(0, 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) __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) + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_14 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_CandleSettingType, __pyx_t_3, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CandleSettingType, __pyx_t_14) < 0) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_CandleSettingType); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error) + __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_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CandleSettingType, __pyx_t_4) < 0) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __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) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_tuple__37); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error) + __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) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_mstate_global->__pyx_n_u_RangeType, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_RangeType, __pyx_n_s_RangeType, (PyObject *) NULL, __pyx_n_s_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__pyx_t_4 != __pyx_tuple__37) { - if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_tuple__37) < 0))) __PYX_ERR(0, 119, __pyx_L1_error) + if (__pyx_t_2 != __pyx_mstate_global->__pyx_tuple[6]) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[6]) < 0))) __PYX_ERR(1, 119, __pyx_L1_error) } - __pyx_t_14 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 120, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if ((likely(PyTuple_CheckExact(__pyx_t_14))) || (PyList_CheckExact(__pyx_t_14))) { - PyObject* sequence = __pyx_t_14; - 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(0, 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_t_18 = PyTuple_GET_ITEM(sequence, 1); - __pyx_t_15 = PyTuple_GET_ITEM(sequence, 2); - } else { - __pyx_t_19 = PyList_GET_ITEM(sequence, 0); - __pyx_t_18 = PyList_GET_ITEM(sequence, 1); - __pyx_t_15 = PyList_GET_ITEM(sequence, 2); - } - __Pyx_INCREF(__pyx_t_19); - __Pyx_INCREF(__pyx_t_18); - __Pyx_INCREF(__pyx_t_15); - #else - __pyx_t_19 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 120, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __pyx_t_18 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 120, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_15 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 120, __pyx_L1_error) + __pyx_t_20 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_20, __pyx_mstate_global->__pyx_int_3}; + __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; + if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); - #endif - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - } else { + } + { Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_14); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) + __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_14); __pyx_t_14 = 0; - __pyx_t_16 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); - index = 0; __pyx_t_19 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_19)) goto __pyx_L9_unpacking_failed; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __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 = 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 = 1; __pyx_t_18 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_18)) goto __pyx_L9_unpacking_failed; - __Pyx_GOTREF(__pyx_t_18); - index = 2; __pyx_t_15 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_15)) goto __pyx_L9_unpacking_failed; - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_6), 3) < 0) __PYX_ERR(0, 120, __pyx_L1_error) - __pyx_t_16 = NULL; + 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_6), 3) < (0)) __PYX_ERR(1, 120, __pyx_L1_error) + __pyx_t_17 = NULL; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L10_unpacking_done; __pyx_L9_unpacking_failed:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_16 = NULL; + __pyx_t_17 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 120, __pyx_L1_error) + __PYX_ERR(1, 120, __pyx_L1_error) __pyx_L10_unpacking_done:; } - if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_RealBody, __pyx_t_19) < 0) __PYX_ERR(0, 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_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_2, __pyx_n_s_HighLow, __pyx_t_18) < 0) __PYX_ERR(0, 120, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_Shadows, __pyx_t_15) < 0) __PYX_ERR(0, 120, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 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_14 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_RangeType, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_RangeType, __pyx_t_14) < 0) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_RangeType); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_RangeType, __pyx_t_3) < 0) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_15_ta_set_candle_settings, 0, __pyx_n_s_ta_set_candle_settings, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 124, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_set_candle_settings, __pyx_t_3) < 0) __PYX_ERR(0, 124, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_17_ta_restore_candle_default_settings, 0, __pyx_n_s_ta_restore_candle_default_setti, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_restore_candle_default_setti, __pyx_t_3) < 0) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_n_s_nan); - __Pyx_GIVEREF(__pyx_n_s_nan); - if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_nan)) __PYX_ERR(3, 2, __pyx_L1_error); - __pyx_t_4 = __Pyx_Import(__pyx_n_s_numpy, __pyx_t_3, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_nan); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2, __pyx_L1_error) + __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); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_nan, __pyx_t_3) < 0) __PYX_ERR(3, 2, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_nan); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_21 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_21 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_5talib_7_ta_lib_NaN = __pyx_t_21; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __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) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_22 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_22 == ((int)-1))) __PYX_ERR(3, 15, __pyx_L1_error) + __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 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_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_19ACOS, 0, __pyx_n_s_ACOS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__45)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ACOS, __pyx_t_4) < 0) __PYX_ERR(3, 142, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 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 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_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_21AD, 0, __pyx_n_s_AD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__47)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_AD, __pyx_t_4) < 0) __PYX_ERR(3, 171, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + { + 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); + { + 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_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_23ADD, 0, __pyx_n_s_ADD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__49)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 203, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADD, __pyx_t_4) < 0) __PYX_ERR(3, 203, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __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); + __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_v_5talib_7_ta_lib_NaN = __pyx_t_22; - __pyx_t_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(4, 15, __pyx_L1_error) - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 234, __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_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(3, 234, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3)) __PYX_ERR(3, 234, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_25ADOSC, 0, __pyx_n_s_ADOSC, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__51)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 234, __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_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADOSC, __pyx_t_3) < 0) __PYX_ERR(3, 234, __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); + #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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 271, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __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); + #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 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 269, __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_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(3, 269, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_27ADX, 0, __pyx_n_s_ADX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__53)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 269, __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 + 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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADX, __pyx_t_3) < 0) __PYX_ERR(3, 269, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 304, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __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); + #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 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 302, __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_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(3, 302, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_29ADXR, 0, __pyx_n_s_ADXR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__54)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 302, __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_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_2); + + __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADXR, __pyx_t_3) < 0) __PYX_ERR(3, 302, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __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); + #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_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 337, __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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 337, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 337, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_14 = PyTuple_New(3); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 335, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_3)) __PYX_ERR(3, 335, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_2)) __PYX_ERR(3, 335, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 2, __pyx_t_4)) __PYX_ERR(3, 335, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_2 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_31APO, 0, __pyx_n_s_APO, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__56)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 335, __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_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_APO, __pyx_t_4) < 0) __PYX_ERR(3, 335, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __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 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_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 370, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 368, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_4)) __PYX_ERR(3, 368, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_33AROON, 0, __pyx_n_s_AROON, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__58)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 368, __pyx_L1_error) + __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_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_AROON, __pyx_t_4) < 0) __PYX_ERR(3, 368, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __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); + #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_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 405, __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_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, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 403, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_4)) __PYX_ERR(3, 403, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_35AROONOSC, 0, __pyx_n_s_AROONOSC, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__60)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 403, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_AROONOSC, __pyx_t_4) < 0) __PYX_ERR(3, 403, __pyx_L1_error) + __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_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_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); + #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_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_37ASIN, 0, __pyx_n_s_ASIN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__61)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 435, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ASIN, __pyx_t_4) < 0) __PYX_ERR(3, 435, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __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_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_39ATAN, 0, __pyx_n_s_ATAN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__62)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 464, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ATAN, __pyx_t_4) < 0) __PYX_ERR(3, 464, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __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_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 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_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 495, __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, 444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 493, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_4)) __PYX_ERR(3, 493, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_41ATR, 0, __pyx_n_s_ATR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__63)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 493, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ATR, __pyx_t_4) < 0) __PYX_ERR(3, 493, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __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_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 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_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_43AVGPRICE, 0, __pyx_n_s_AVGPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__65)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 526, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_AVGPRICE, __pyx_t_4) < 0) __PYX_ERR(3, 526, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __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 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_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_14 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 560, __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 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 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = PyTuple_New(4); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 558, __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_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_4)) __PYX_ERR(3, 558, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_14)) __PYX_ERR(3, 558, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 2, __pyx_t_2)) __PYX_ERR(3, 558, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 3, __pyx_t_3)) __PYX_ERR(3, 558, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_14 = 0; - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_45BBANDS, 0, __pyx_n_s_BBANDS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__67)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 558, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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 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_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 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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + __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_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 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 = __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_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); + + __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_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_BBANDS, __pyx_t_3) < 0) __PYX_ERR(3, 558, __pyx_L1_error) + __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_BBANDS, __pyx_t_3) < (0)) __PYX_ERR(4, 628, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 600, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 598, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 598, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_47BETA, 0, __pyx_n_s_BETA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__69)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 598, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_BETA, __pyx_t_3) < 0) __PYX_ERR(3, 598, __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_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_3) < (0)) __PYX_ERR(4, 668, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_49BOP, 0, __pyx_n_s_BOP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__70)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 631, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_BOP, __pyx_t_3) < 0) __PYX_ERR(3, 631, __pyx_L1_error) + #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_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 665, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 663, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 663, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_51CCI, 0, __pyx_n_s_CCI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__71)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 663, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CCI, __pyx_t_3) < 0) __PYX_ERR(3, 663, __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_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_3) < (0)) __PYX_ERR(4, 733, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_53CDL2CROWS, 0, __pyx_n_s_CDL2CROWS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__73)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 696, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL2CROWS, __pyx_t_3) < 0) __PYX_ERR(3, 696, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_55CDL3BLACKCROWS, 0, __pyx_n_s_CDL3BLACKCROWS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__74)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 728, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3BLACKCROWS, __pyx_t_3) < 0) __PYX_ERR(3, 728, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_57CDL3INSIDE, 0, __pyx_n_s_CDL3INSIDE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__75)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 760, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3INSIDE, __pyx_t_3) < 0) __PYX_ERR(3, 760, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_59CDL3LINESTRIKE, 0, __pyx_n_s_CDL3LINESTRIKE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__76)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 792, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3LINESTRIKE, __pyx_t_3) < 0) __PYX_ERR(3, 792, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_61CDL3OUTSIDE, 0, __pyx_n_s_CDL3OUTSIDE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__77)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 824, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3OUTSIDE, __pyx_t_3) < 0) __PYX_ERR(3, 824, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_63CDL3STARSINSOUTH, 0, __pyx_n_s_CDL3STARSINSOUTH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__78)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 856, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3STARSINSOUTH, __pyx_t_3) < 0) __PYX_ERR(3, 856, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_65CDL3WHITESOLDIERS, 0, __pyx_n_s_CDL3WHITESOLDIERS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__79)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 888, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3WHITESOLDIERS, __pyx_t_3) < 0) __PYX_ERR(3, 888, __pyx_L1_error) + #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_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 922, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 920, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 920, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_67CDLABANDONEDBABY, 0, __pyx_n_s_CDLABANDONEDBABY, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__81)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 920, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLABANDONEDBABY, __pyx_t_3) < 0) __PYX_ERR(3, 920, __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_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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_69CDLADVANCEBLOCK, 0, __pyx_n_s_CDLADVANCEBLOCK, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__82)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 954, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLADVANCEBLOCK, __pyx_t_3) < 0) __PYX_ERR(3, 954, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_71CDLBELTHOLD, 0, __pyx_n_s_CDLBELTHOLD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__83)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 986, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLBELTHOLD, __pyx_t_3) < 0) __PYX_ERR(3, 986, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_73CDLBREAKAWAY, 0, __pyx_n_s_CDLBREAKAWAY, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__84)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1018, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLBREAKAWAY, __pyx_t_3) < 0) __PYX_ERR(3, 1018, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU, 0, __pyx_n_s_CDLCLOSINGMARUBOZU, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__85)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1050, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLCLOSINGMARUBOZU, __pyx_t_3) < 0) __PYX_ERR(3, 1050, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_77CDLCONCEALBABYSWALL, 0, __pyx_n_s_CDLCONCEALBABYSWALL, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__86)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1082, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLCONCEALBABYSWALL, __pyx_t_3) < 0) __PYX_ERR(3, 1082, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_79CDLCOUNTERATTACK, 0, __pyx_n_s_CDLCOUNTERATTACK, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__87)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1114, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLCOUNTERATTACK, __pyx_t_3) < 0) __PYX_ERR(3, 1114, __pyx_L1_error) + #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_3 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1148, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 1146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 1146, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_81CDLDARKCLOUDCOVER, 0, __pyx_n_s_CDLDARKCLOUDCOVER, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__88)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1146, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLDARKCLOUDCOVER, __pyx_t_3) < 0) __PYX_ERR(3, 1146, __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_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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_83CDLDOJI, 0, __pyx_n_s_CDLDOJI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__89)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1180, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLDOJI, __pyx_t_3) < 0) __PYX_ERR(3, 1180, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_85CDLDOJISTAR, 0, __pyx_n_s_CDLDOJISTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__90)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1212, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLDOJISTAR, __pyx_t_3) < 0) __PYX_ERR(3, 1212, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_87CDLDRAGONFLYDOJI, 0, __pyx_n_s_CDLDRAGONFLYDOJI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__91)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1244, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLDRAGONFLYDOJI, __pyx_t_3) < 0) __PYX_ERR(3, 1244, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_89CDLENGULFING, 0, __pyx_n_s_CDLENGULFING, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__92)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1276, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLENGULFING, __pyx_t_3) < 0) __PYX_ERR(3, 1276, __pyx_L1_error) + #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_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1310, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 1308, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 1308, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_91CDLEVENINGDOJISTAR, 0, __pyx_n_s_CDLEVENINGDOJISTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__93)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1308, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLEVENINGDOJISTAR, __pyx_t_3) < 0) __PYX_ERR(3, 1308, __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_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_3) < (0)) __PYX_ERR(4, 1378, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1344, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 1342, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 1342, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_93CDLEVENINGSTAR, 0, __pyx_n_s_CDLEVENINGSTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__94)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1342, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLEVENINGSTAR, __pyx_t_3) < 0) __PYX_ERR(3, 1342, __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_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_3) < (0)) __PYX_ERR(4, 1412, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE, 0, __pyx_n_s_CDLGAPSIDESIDEWHITE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__95)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1376, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLGAPSIDESIDEWHITE, __pyx_t_3) < 0) __PYX_ERR(3, 1376, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_97CDLGRAVESTONEDOJI, 0, __pyx_n_s_CDLGRAVESTONEDOJI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__96)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1408, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLGRAVESTONEDOJI, __pyx_t_3) < 0) __PYX_ERR(3, 1408, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_99CDLHAMMER, 0, __pyx_n_s_CDLHAMMER, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__97)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1440, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHAMMER, __pyx_t_3) < 0) __PYX_ERR(3, 1440, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_101CDLHANGINGMAN, 0, __pyx_n_s_CDLHANGINGMAN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__98)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1472, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHANGINGMAN, __pyx_t_3) < 0) __PYX_ERR(3, 1472, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_103CDLHARAMI, 0, __pyx_n_s_CDLHARAMI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__99)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1504, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHARAMI, __pyx_t_3) < 0) __PYX_ERR(3, 1504, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_105CDLHARAMICROSS, 0, __pyx_n_s_CDLHARAMICROSS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__100)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1536, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHARAMICROSS, __pyx_t_3) < 0) __PYX_ERR(3, 1536, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_107CDLHIGHWAVE, 0, __pyx_n_s_CDLHIGHWAVE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__101)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1568, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHIGHWAVE, __pyx_t_3) < 0) __PYX_ERR(3, 1568, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_109CDLHIKKAKE, 0, __pyx_n_s_CDLHIKKAKE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__102)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1600, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHIKKAKE, __pyx_t_3) < 0) __PYX_ERR(3, 1600, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_111CDLHIKKAKEMOD, 0, __pyx_n_s_CDLHIKKAKEMOD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__103)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1632, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHIKKAKEMOD, __pyx_t_3) < 0) __PYX_ERR(3, 1632, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_113CDLHOMINGPIGEON, 0, __pyx_n_s_CDLHOMINGPIGEON, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__104)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1664, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHOMINGPIGEON, __pyx_t_3) < 0) __PYX_ERR(3, 1664, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_115CDLIDENTICAL3CROWS, 0, __pyx_n_s_CDLIDENTICAL3CROWS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__105)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1696, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLIDENTICAL3CROWS, __pyx_t_3) < 0) __PYX_ERR(3, 1696, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_117CDLINNECK, 0, __pyx_n_s_CDLINNECK, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__106)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1728, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLINNECK, __pyx_t_3) < 0) __PYX_ERR(3, 1728, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_119CDLINVERTEDHAMMER, 0, __pyx_n_s_CDLINVERTEDHAMMER, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__107)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1760, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLINVERTEDHAMMER, __pyx_t_3) < 0) __PYX_ERR(3, 1760, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_121CDLKICKING, 0, __pyx_n_s_CDLKICKING, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__108)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1792, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLKICKING, __pyx_t_3) < 0) __PYX_ERR(3, 1792, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_123CDLKICKINGBYLENGTH, 0, __pyx_n_s_CDLKICKINGBYLENGTH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__109)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1824, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLKICKINGBYLENGTH, __pyx_t_3) < 0) __PYX_ERR(3, 1824, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_125CDLLADDERBOTTOM, 0, __pyx_n_s_CDLLADDERBOTTOM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__110)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1856, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLLADDERBOTTOM, __pyx_t_3) < 0) __PYX_ERR(3, 1856, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI, 0, __pyx_n_s_CDLLONGLEGGEDDOJI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__111)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1888, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLLONGLEGGEDDOJI, __pyx_t_3) < 0) __PYX_ERR(3, 1888, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_129CDLLONGLINE, 0, __pyx_n_s_CDLLONGLINE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__112)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1920, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLLONGLINE, __pyx_t_3) < 0) __PYX_ERR(3, 1920, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_131CDLMARUBOZU, 0, __pyx_n_s_CDLMARUBOZU, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__113)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1952, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMARUBOZU, __pyx_t_3) < 0) __PYX_ERR(3, 1952, __pyx_L1_error) + #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_133CDLMATCHINGLOW, 0, __pyx_n_s_CDLMATCHINGLOW, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__114)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1984, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMATCHINGLOW, __pyx_t_3) < 0) __PYX_ERR(3, 1984, __pyx_L1_error) + #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(3, 2018, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 2016, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 2016, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_135CDLMATHOLD, 0, __pyx_n_s_CDLMATHOLD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__115)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2016, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMATHOLD, __pyx_t_3) < 0) __PYX_ERR(3, 2016, __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_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_3) < (0)) __PYX_ERR(4, 2086, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2052, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 2050, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 2050, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_137CDLMORNINGDOJISTAR, 0, __pyx_n_s_CDLMORNINGDOJISTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__116)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2050, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMORNINGDOJISTAR, __pyx_t_3) < 0) __PYX_ERR(3, 2050, __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_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_3) < (0)) __PYX_ERR(4, 2120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2086, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 2084, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 2084, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_139CDLMORNINGSTAR, 0, __pyx_n_s_CDLMORNINGSTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__117)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2084, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMORNINGSTAR, __pyx_t_3) < 0) __PYX_ERR(3, 2084, __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_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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_141CDLONNECK, 0, __pyx_n_s_CDLONNECK, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__118)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2118, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLONNECK, __pyx_t_3) < 0) __PYX_ERR(3, 2118, __pyx_L1_error) + #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_143CDLPIERCING, 0, __pyx_n_s_CDLPIERCING, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__119)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2150, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLPIERCING, __pyx_t_3) < 0) __PYX_ERR(3, 2150, __pyx_L1_error) + #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_145CDLRICKSHAWMAN, 0, __pyx_n_s_CDLRICKSHAWMAN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__120)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2182, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLRICKSHAWMAN, __pyx_t_3) < 0) __PYX_ERR(3, 2182, __pyx_L1_error) + #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_147CDLRISEFALL3METHODS, 0, __pyx_n_s_CDLRISEFALL3METHODS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__121)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2214, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLRISEFALL3METHODS, __pyx_t_3) < 0) __PYX_ERR(3, 2214, __pyx_L1_error) + #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_149CDLSEPARATINGLINES, 0, __pyx_n_s_CDLSEPARATINGLINES, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__122)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2246, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSEPARATINGLINES, __pyx_t_3) < 0) __PYX_ERR(3, 2246, __pyx_L1_error) + #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_151CDLSHOOTINGSTAR, 0, __pyx_n_s_CDLSHOOTINGSTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__123)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2278, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSHOOTINGSTAR, __pyx_t_3) < 0) __PYX_ERR(3, 2278, __pyx_L1_error) + #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_153CDLSHORTLINE, 0, __pyx_n_s_CDLSHORTLINE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__124)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2310, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSHORTLINE, __pyx_t_3) < 0) __PYX_ERR(3, 2310, __pyx_L1_error) + #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_155CDLSPINNINGTOP, 0, __pyx_n_s_CDLSPINNINGTOP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__125)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2342, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSPINNINGTOP, __pyx_t_3) < 0) __PYX_ERR(3, 2342, __pyx_L1_error) + #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_157CDLSTALLEDPATTERN, 0, __pyx_n_s_CDLSTALLEDPATTERN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__126)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2374, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSTALLEDPATTERN, __pyx_t_3) < 0) __PYX_ERR(3, 2374, __pyx_L1_error) + #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_159CDLSTICKSANDWICH, 0, __pyx_n_s_CDLSTICKSANDWICH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__127)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2406, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSTICKSANDWICH, __pyx_t_3) < 0) __PYX_ERR(3, 2406, __pyx_L1_error) + #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_161CDLTAKURI, 0, __pyx_n_s_CDLTAKURI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__128)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2438, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLTAKURI, __pyx_t_3) < 0) __PYX_ERR(3, 2438, __pyx_L1_error) + #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_163CDLTASUKIGAP, 0, __pyx_n_s_CDLTASUKIGAP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__129)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2470, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLTASUKIGAP, __pyx_t_3) < 0) __PYX_ERR(3, 2470, __pyx_L1_error) + #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_165CDLTHRUSTING, 0, __pyx_n_s_CDLTHRUSTING, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__130)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2502, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLTHRUSTING, __pyx_t_3) < 0) __PYX_ERR(3, 2502, __pyx_L1_error) + #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_167CDLTRISTAR, 0, __pyx_n_s_CDLTRISTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__131)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2534, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLTRISTAR, __pyx_t_3) < 0) __PYX_ERR(3, 2534, __pyx_L1_error) + #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_169CDLUNIQUE3RIVER, 0, __pyx_n_s_CDLUNIQUE3RIVER, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__132)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2566, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLUNIQUE3RIVER, __pyx_t_3) < 0) __PYX_ERR(3, 2566, __pyx_L1_error) + #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_171CDLUPSIDEGAP2CROWS, 0, __pyx_n_s_CDLUPSIDEGAP2CROWS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__133)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2598, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLUPSIDEGAP2CROWS, __pyx_t_3) < 0) __PYX_ERR(3, 2598, __pyx_L1_error) + #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_173CDLXSIDEGAP3METHODS, 0, __pyx_n_s_CDLXSIDEGAP3METHODS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__134)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2630, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLXSIDEGAP3METHODS, __pyx_t_3) < 0) __PYX_ERR(3, 2630, __pyx_L1_error) + #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_175CEIL, 0, __pyx_n_s_CEIL, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__135)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2662, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_CEIL, __pyx_t_3) < 0) __PYX_ERR(3, 2662, __pyx_L1_error) + #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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2693, __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 2691, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 2691, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_177CMO, 0, __pyx_n_s_CMO, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__137)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2691, __pyx_L1_error) + __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CMO, __pyx_t_3) < 0) __PYX_ERR(3, 2691, __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_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_3) < (0)) __PYX_ERR(4, 2761, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2724, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 2722, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 2722, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_179CORREL, 0, __pyx_n_s_CORREL, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__138)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2722, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CORREL, __pyx_t_3) < 0) __PYX_ERR(3, 2722, __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_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_181COS, 0, __pyx_n_s_COS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__139)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2755, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_COS, __pyx_t_3) < 0) __PYX_ERR(3, 2755, __pyx_L1_error) + #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_183COSH, 0, __pyx_n_s_COSH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__140)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2784, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_COSH, __pyx_t_3) < 0) __PYX_ERR(3, 2784, __pyx_L1_error) + #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_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2815, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 2813, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 2813, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_185DEMA, 0, __pyx_n_s_DEMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__141)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2813, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_DEMA, __pyx_t_3) < 0) __PYX_ERR(3, 2813, __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_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_3) < (0)) __PYX_ERR(4, 2883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_187DIV, 0, __pyx_n_s_DIV, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__142)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2844, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_DIV, __pyx_t_3) < 0) __PYX_ERR(3, 2844, __pyx_L1_error) + #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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2877, __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 2875, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 2875, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_189DX, 0, __pyx_n_s_DX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__143)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2875, __pyx_L1_error) + __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_DX, __pyx_t_3) < 0) __PYX_ERR(3, 2875, __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_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_3) < (0)) __PYX_ERR(4, 2945, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2910, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 2908, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 2908, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_191EMA, 0, __pyx_n_s_EMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__144)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2908, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_EMA, __pyx_t_3) < 0) __PYX_ERR(3, 2908, __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_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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_193EXP, 0, __pyx_n_s_EXP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__145)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2939, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_EXP, __pyx_t_3) < 0) __PYX_ERR(3, 2939, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_195FLOOR, 0, __pyx_n_s_FLOOR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__146)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2968, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_FLOOR, __pyx_t_3) < 0) __PYX_ERR(3, 2968, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_197HT_DCPERIOD, 0, __pyx_n_s_HT_DCPERIOD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__147)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2997, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_DCPERIOD, __pyx_t_3) < 0) __PYX_ERR(3, 2997, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_199HT_DCPHASE, 0, __pyx_n_s_HT_DCPHASE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__148)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3026, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_DCPHASE, __pyx_t_3) < 0) __PYX_ERR(3, 3026, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_201HT_PHASOR, 0, __pyx_n_s_HT_PHASOR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__150)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3055, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_PHASOR, __pyx_t_3) < 0) __PYX_ERR(3, 3055, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_203HT_SINE, 0, __pyx_n_s_HT_SINE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__152)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3087, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_SINE, __pyx_t_3) < 0) __PYX_ERR(3, 3087, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_205HT_TRENDLINE, 0, __pyx_n_s_HT_TRENDLINE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__153)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3119, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_TRENDLINE, __pyx_t_3) < 0) __PYX_ERR(3, 3119, __pyx_L1_error) + #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_207HT_TRENDMODE, 0, __pyx_n_s_HT_TRENDMODE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__155)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3148, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_TRENDMODE, __pyx_t_3) < 0) __PYX_ERR(3, 3148, __pyx_L1_error) + #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_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3179, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 3177, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_209KAMA, 0, __pyx_n_s_KAMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__156)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3177, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_KAMA, __pyx_t_3) < 0) __PYX_ERR(3, 3177, __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_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_3) < (0)) __PYX_ERR(4, 3247, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3210, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 3208, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_211LINEARREG, 0, __pyx_n_s_LINEARREG, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__157)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3208, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_LINEARREG, __pyx_t_3) < 0) __PYX_ERR(3, 3208, __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_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_3) < (0)) __PYX_ERR(4, 3279, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3241, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3239, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 3239, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_213LINEARREG_ANGLE, 0, __pyx_n_s_LINEARREG_ANGLE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__158)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3239, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_LINEARREG_ANGLE, __pyx_t_3) < 0) __PYX_ERR(3, 3239, __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_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_3) < (0)) __PYX_ERR(4, 3310, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3272, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3270, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 3270, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_215LINEARREG_INTERCEPT, 0, __pyx_n_s_LINEARREG_INTERCEPT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__159)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3270, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_LINEARREG_INTERCEPT, __pyx_t_3) < 0) __PYX_ERR(3, 3270, __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_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_3) < (0)) __PYX_ERR(4, 3341, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3303, __pyx_L1_error) + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3)) __PYX_ERR(3, 3301, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_217LINEARREG_SLOPE, 0, __pyx_n_s_LINEARREG_SLOPE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__160)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3301, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_LINEARREG_SLOPE, __pyx_t_3) < 0) __PYX_ERR(3, 3301, __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_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_3) < (0)) __PYX_ERR(4, 3372, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_219LN, 0, __pyx_n_s_LN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__161)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3332, __pyx_L1_error) + __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_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3403, __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_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 (PyDict_SetItem(__pyx_d, __pyx_n_s_LN, __pyx_t_3) < 0) __PYX_ERR(3, 3332, __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_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_3) < (0)) __PYX_ERR(4, 3403, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_221LOG10, 0, __pyx_n_s_LOG10, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__162)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3361, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_LOG10, __pyx_t_3) < 0) __PYX_ERR(3, 3361, __pyx_L1_error) + #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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3392, __pyx_L1_error) + __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); - __pyx_t_15 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3392, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + #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 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3390, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(3, 3390, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_15)) __PYX_ERR(3, 3390, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_15 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_223MA, 0, __pyx_n_s_MA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__164)); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3390, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MA, __pyx_t_15) < 0) __PYX_ERR(3, 3390, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __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_15 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3424, __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_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) + __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_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_14 = PyTuple_New(3); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 3422, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_15)) __PYX_ERR(3, 3422, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_2)) __PYX_ERR(3, 3422, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 2, __pyx_t_3)) __PYX_ERR(3, 3422, __pyx_L1_error); - __pyx_t_15 = 0; - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_225MACD, 0, __pyx_n_s_MACD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__166)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3422, __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MACD, __pyx_t_3) < 0) __PYX_ERR(3, 3422, __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_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_3) < (0)) __PYX_ERR(4, 3524, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3463, __pyx_L1_error) + __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_14 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 3463, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3463, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_15 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3463, __pyx_L1_error) + __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_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3463, __pyx_L1_error) + __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_18 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3463, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - - __pyx_t_19 = PyTuple_New(6); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 3461, __pyx_L1_error) + __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_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_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_3)) __PYX_ERR(3, 3461, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 1, __pyx_t_14)) __PYX_ERR(3, 3461, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 2, __pyx_t_2)) __PYX_ERR(3, 3461, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 3, __pyx_t_15)) __PYX_ERR(3, 3461, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 4, __pyx_t_4)) __PYX_ERR(3, 3461, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 5, __pyx_t_18)) __PYX_ERR(3, 3461, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_14 = 0; - __pyx_t_2 = 0; - __pyx_t_15 = 0; - __pyx_t_4 = 0; - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_227MACDEXT, 0, __pyx_n_s_MACDEXT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__168)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3461, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_19); - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MACDEXT, __pyx_t_18) < 0) __PYX_ERR(3, 3461, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3505, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 3503, __pyx_L1_error) + __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_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_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); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_18)) __PYX_ERR(3, 3503, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_229MACDFIX, 0, __pyx_n_s_MACDFIX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__170)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3503, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __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; + 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_d, __pyx_n_s_MACDFIX, __pyx_t_18) < 0) __PYX_ERR(3, 3503, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __pyx_t_18 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3542, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 3542, __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_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3540, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_18)) __PYX_ERR(3, 3540, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_19); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_19)) __PYX_ERR(3, 3540, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_19 = 0; - __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_231MAMA, 0, __pyx_n_s_MAMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__172)); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 3540, __pyx_L1_error) + __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_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_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAMA, __pyx_t_19) < 0) __PYX_ERR(3, 3540, __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_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 3577, __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_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_18 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - - __pyx_t_15 = PyTuple_New(3); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3575, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_19); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_19)) __PYX_ERR(3, 3575, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_4)) __PYX_ERR(3, 3575, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 2, __pyx_t_18)) __PYX_ERR(3, 3575, __pyx_L1_error); - __pyx_t_19 = 0; - __pyx_t_4 = 0; - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_233MAVP, 0, __pyx_n_s_MAVP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__174)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3575, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAVP, __pyx_t_18) < 0) __PYX_ERR(3, 3575, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - - __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3610, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3610, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_235MAX, 0, __pyx_n_s_MAX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__175)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3610, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAX, __pyx_t_18) < 0) __PYX_ERR(3, 3610, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3643, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - - __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3641, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3641, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_237MAXINDEX, 0, __pyx_n_s_MAXINDEX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__177)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3641, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAXINDEX, __pyx_t_18) < 0) __PYX_ERR(3, 3641, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_239MEDPRICE, 0, __pyx_n_s_MEDPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__179)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3675, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MEDPRICE, __pyx_t_18) < 0) __PYX_ERR(3, 3675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3707, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - - __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3705, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3705, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_241MFI, 0, __pyx_n_s_MFI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__181)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3705, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MFI, __pyx_t_18) < 0) __PYX_ERR(3, 3705, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3741, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_20); __pyx_t_20 = 0; + __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); + #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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3739, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3739, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_243MIDPOINT, 0, __pyx_n_s_MIDPOINT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__182)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3739, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MIDPOINT, __pyx_t_18) < 0) __PYX_ERR(3, 3739, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3772, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_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_MAVP, __pyx_t_19) < (0)) __PYX_ERR(4, 3677, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3770, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3770, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_245MIDPRICE, 0, __pyx_n_s_MIDPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__183)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3770, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MIDPRICE, __pyx_t_18) < 0) __PYX_ERR(3, 3770, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3804, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_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_MAX, __pyx_t_19) < (0)) __PYX_ERR(4, 3712, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3802, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3802, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_247MIN, 0, __pyx_n_s_MIN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__184)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3802, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MIN, __pyx_t_18) < 0) __PYX_ERR(3, 3802, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3835, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_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_MAXINDEX, __pyx_t_19) < (0)) __PYX_ERR(4, 3743, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3833, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3833, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_249MININDEX, 0, __pyx_n_s_MININDEX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__185)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3833, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MININDEX, __pyx_t_18) < 0) __PYX_ERR(3, 3833, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3869, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3867, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3867, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_251MINMAX, 0, __pyx_n_s_MINMAX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__187)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3867, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINMAX, __pyx_t_18) < 0) __PYX_ERR(3, 3867, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_MFI, __pyx_t_19) < (0)) __PYX_ERR(4, 3807, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3903, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3901, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3901, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_253MINMAXINDEX, 0, __pyx_n_s_MINMAXINDEX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__189)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3901, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINMAXINDEX, __pyx_t_18) < 0) __PYX_ERR(3, 3901, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_MIDPOINT, __pyx_t_19) < (0)) __PYX_ERR(4, 3841, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3943, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3941, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3941, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_255MINUS_DI, 0, __pyx_n_s_MINUS_DI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__190)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3941, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINUS_DI, __pyx_t_18) < 0) __PYX_ERR(3, 3941, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_MIDPRICE, __pyx_t_19) < (0)) __PYX_ERR(4, 3872, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3976, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 3974, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 3974, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_257MINUS_DM, 0, __pyx_n_s_MINUS_DM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__191)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 3974, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINUS_DM, __pyx_t_18) < 0) __PYX_ERR(3, 3974, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_MIN, __pyx_t_19) < (0)) __PYX_ERR(4, 3904, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4008, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 4006, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 4006, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_259MOM, 0, __pyx_n_s_MOM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__192)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4006, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MOM, __pyx_t_18) < 0) __PYX_ERR(3, 4006, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_MININDEX, __pyx_t_19) < (0)) __PYX_ERR(4, 3935, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_261MULT, 0, __pyx_n_s_MULT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__193)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4037, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MULT, __pyx_t_18) < 0) __PYX_ERR(3, 4037, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4070, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_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_MINMAX, __pyx_t_19) < (0)) __PYX_ERR(4, 3969, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 4068, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 4068, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_263NATR, 0, __pyx_n_s_NATR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__194)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4068, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_NATR, __pyx_t_18) < 0) __PYX_ERR(3, 4068, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_265OBV, 0, __pyx_n_s_OBV, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__196)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_OBV, __pyx_t_18) < 0) __PYX_ERR(3, 4101, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_MINMAXINDEX, __pyx_t_19) < (0)) __PYX_ERR(4, 4003, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 4132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 4132, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_267PLUS_DI, 0, __pyx_n_s_PLUS_DI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__197)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_PLUS_DI, __pyx_t_18) < 0) __PYX_ERR(3, 4132, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_DI, __pyx_t_19) < (0)) __PYX_ERR(4, 4043, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 4165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(3, 4165, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_269PLUS_DM, 0, __pyx_n_s_PLUS_DM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__198)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_PLUS_DM, __pyx_t_18) < 0) __PYX_ERR(3, 4165, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_MINUS_DM, __pyx_t_19) < (0)) __PYX_ERR(4, 4076, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_15 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 4199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_4 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __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_19 = PyTuple_New(3); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 4197, __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_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); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_18)) __PYX_ERR(3, 4197, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 1, __pyx_t_15)) __PYX_ERR(3, 4197, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 2, __pyx_t_4)) __PYX_ERR(3, 4197, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_15 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_271PPO, 0, __pyx_n_s_PPO, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__199)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4197, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __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_19) < (0)) __PYX_ERR(4, 4108, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_PPO, __pyx_t_4) < 0) __PYX_ERR(3, 4197, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - __pyx_t_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 4230, __pyx_L1_error) + __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); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_4)) __PYX_ERR(3, 4230, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_273ROC, 0, __pyx_n_s_ROC, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__200)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROC, __pyx_t_4) < 0) __PYX_ERR(3, 4230, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4263, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __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_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 4261, __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_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); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_4)) __PYX_ERR(3, 4261, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_275ROCP, 0, __pyx_n_s_ROCP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__201)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4261, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __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_19) < (0)) __PYX_ERR(4, 4170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROCP, __pyx_t_4) < 0) __PYX_ERR(3, 4261, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4294, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - - __pyx_t_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 4292, __pyx_L1_error) + __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); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_4)) __PYX_ERR(3, 4292, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_277ROCR, 0, __pyx_n_s_ROCR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__202)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROCR, __pyx_t_4) < 0) __PYX_ERR(3, 4292, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __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_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 4323, __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_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_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_4)) __PYX_ERR(3, 4323, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_279ROCR100, 0, __pyx_n_s_ROCR100, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__203)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4323, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __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_19) < (0)) __PYX_ERR(4, 4234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROCR100, __pyx_t_4) < 0) __PYX_ERR(3, 4323, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4356, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __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_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 4354, __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_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_4)) __PYX_ERR(3, 4354, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_281RSI, 0, __pyx_n_s_RSI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__204)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4354, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __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_d, __pyx_n_s_RSI, __pyx_t_4) < 0) __PYX_ERR(3, 4354, __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(3, 4387, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_19 = PyFloat_FromDouble(((double)0.2)); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 4387, __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_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_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 4385, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_4)) __PYX_ERR(3, 4385, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_19); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_19)) __PYX_ERR(3, 4385, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_19 = 0; - __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_283SAR, 0, __pyx_n_s_SAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__206)); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 4385, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAR, __pyx_t_19) < 0) __PYX_ERR(3, 4385, __pyx_L1_error) + __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; + __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_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_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_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_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_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_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_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_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(3, 4420, __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_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_20) < (0)) __PYX_ERR(4, 4487, __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, 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_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 4420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4420, __pyx_L1_error) + __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_18 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_14 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 4420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4420, __pyx_L1_error) + __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_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(3, 4420, __pyx_L1_error) + __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_t_7 = PyTuple_New(8); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4418, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_19); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_19)) __PYX_ERR(3, 4418, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_15)) __PYX_ERR(3, 4418, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_4)) __PYX_ERR(3, 4418, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_18)) __PYX_ERR(3, 4418, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_t_2)) __PYX_ERR(3, 4418, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 5, __pyx_t_14)) __PYX_ERR(3, 4418, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 6, __pyx_t_3)) __PYX_ERR(3, 4418, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 7, __pyx_t_6)) __PYX_ERR(3, 4418, __pyx_L1_error); - __pyx_t_19 = 0; - __pyx_t_15 = 0; - __pyx_t_4 = 0; - __pyx_t_18 = 0; - __pyx_t_2 = 0; - __pyx_t_14 = 0; - __pyx_t_3 = 0; - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_285SAREXT, 0, __pyx_n_s_SAREXT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__208)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4418, __pyx_L1_error) + __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAREXT, __pyx_t_6) < 0) __PYX_ERR(3, 4418, __pyx_L1_error) + #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; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_287SIN, 0, __pyx_n_s_SIN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__209)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4457, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_SIN, __pyx_t_6) < 0) __PYX_ERR(3, 4457, __pyx_L1_error) + #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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_289SINH, 0, __pyx_n_s_SINH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__210)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4486, __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); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SINH, __pyx_t_6) < 0) __PYX_ERR(3, 4486, __pyx_L1_error) + #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; - __pyx_t_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4517, __pyx_L1_error) + __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 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6)) __PYX_ERR(3, 4515, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_291SMA, 0, __pyx_n_s_SMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__211)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4515, __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SMA, __pyx_t_6) < 0) __PYX_ERR(3, 4515, __pyx_L1_error) + #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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_293SQRT, 0, __pyx_n_s_SQRT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__212)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4546, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_SQRT, __pyx_t_6) < 0) __PYX_ERR(3, 4546, __pyx_L1_error) + #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_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4577, __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_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __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_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4575, __pyx_L1_error) + __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_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6)) __PYX_ERR(3, 4575, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7)) __PYX_ERR(3, 4575, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_295STDDEV, 0, __pyx_n_s_STDDEV, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__214)); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4575, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __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_d, __pyx_n_s_STDDEV, __pyx_t_7) < 0) __PYX_ERR(3, 4575, __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_STDDEV, __pyx_t_8) < (0)) __PYX_ERR(4, 4677, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4609, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4609, __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_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4609, __pyx_L1_error) + __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_14 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 4609, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_2 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4609, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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_18 = PyTuple_New(5); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4607, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_7)) __PYX_ERR(3, 4607, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_3)) __PYX_ERR(3, 4607, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 2, __pyx_t_6)) __PYX_ERR(3, 4607, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 3, __pyx_t_14)) __PYX_ERR(3, 4607, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 4, __pyx_t_2)) __PYX_ERR(3, 4607, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_3 = 0; - __pyx_t_6 = 0; - __pyx_t_14 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_297STOCH, 0, __pyx_n_s_STOCH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__216)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4607, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_STOCH, __pyx_t_2) < 0) __PYX_ERR(3, 4607, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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_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); + #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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4649, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4649, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_14 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 4649, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); + __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_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_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4647, __pyx_L1_error) + __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_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2)) __PYX_ERR(3, 4647, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_18)) __PYX_ERR(3, 4647, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_14)) __PYX_ERR(3, 4647, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_18 = 0; - __pyx_t_14 = 0; - __pyx_t_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_299STOCHF, 0, __pyx_n_s_STOCHF, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__218)); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 4647, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_14, __pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 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); + #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_d, __pyx_n_s_STOCHF, __pyx_t_14) < 0) __PYX_ERR(3, 4647, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 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_14 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 4687, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4687, __pyx_L1_error) + __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_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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4687, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_2 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4687, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4685, __pyx_L1_error) + __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_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_14)) __PYX_ERR(3, 4685, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6)) __PYX_ERR(3, 4685, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_18)) __PYX_ERR(3, 4685, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2)) __PYX_ERR(3, 4685, __pyx_L1_error); - __pyx_t_14 = 0; - __pyx_t_6 = 0; - __pyx_t_18 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_301STOCHRSI, 0, __pyx_n_s_STOCHRSI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__220)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4685, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 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); + #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_d, __pyx_n_s_STOCHRSI, __pyx_t_2) < 0) __PYX_ERR(3, 4685, __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_STOCHRSI, __pyx_t_4) < (0)) __PYX_ERR(4, 4787, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_303SUB, 0, __pyx_n_s_SUB, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__221)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4722, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUB, __pyx_t_2) < 0) __PYX_ERR(3, 4722, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4755, __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, 4857, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4753, __pyx_L1_error) + __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_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(3, 4753, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_305SUM, 0, __pyx_n_s_SUM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__222)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4753, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __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); + #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_d, __pyx_n_s_SUM, __pyx_t_2) < 0) __PYX_ERR(3, 4753, __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_SUM, __pyx_t_4) < (0)) __PYX_ERR(4, 4855, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4786, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4786, __pyx_L1_error) + __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_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4784, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_2)) __PYX_ERR(3, 4784, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_3)) __PYX_ERR(3, 4784, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_307T3, 0, __pyx_n_s_T3, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__224)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4784, __pyx_L1_error) + __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_T3, __pyx_t_3) < 0) __PYX_ERR(3, 4784, __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_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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_309TAN, 0, __pyx_n_s_TAN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__225)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4816, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_TAN, __pyx_t_3) < 0) __PYX_ERR(3, 4816, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_311TANH, 0, __pyx_n_s_TANH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__226)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4845, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_TANH, __pyx_t_3) < 0) __PYX_ERR(3, 4845, __pyx_L1_error) + #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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4876, __pyx_L1_error) + __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_18 = PyTuple_New(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4874, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_3)) __PYX_ERR(3, 4874, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_313TEMA, 0, __pyx_n_s_TEMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__227)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4874, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TEMA, __pyx_t_3) < 0) __PYX_ERR(3, 4874, __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_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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_315TRANGE, 0, __pyx_n_s_TRANGE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__229)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4905, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_TRANGE, __pyx_t_3) < 0) __PYX_ERR(3, 4905, __pyx_L1_error) + #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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4938, __pyx_L1_error) + __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_18 = PyTuple_New(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4936, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_3)) __PYX_ERR(3, 4936, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_317TRIMA, 0, __pyx_n_s_TRIMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__230)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4936, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TRIMA, __pyx_t_3) < 0) __PYX_ERR(3, 4936, __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_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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4969, __pyx_L1_error) + __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_18 = PyTuple_New(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4967, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_3)) __PYX_ERR(3, 4967, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_319TRIX, 0, __pyx_n_s_TRIX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__231)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4967, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TRIX, __pyx_t_3) < 0) __PYX_ERR(3, 4967, __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_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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 5000, __pyx_L1_error) + __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_18 = PyTuple_New(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 4998, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_3)) __PYX_ERR(3, 4998, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_321TSF, 0, __pyx_n_s_TSF, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__232)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4998, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TSF, __pyx_t_3) < 0) __PYX_ERR(3, 4998, __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_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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_323TYPPRICE, 0, __pyx_n_s_TYPPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__233)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 5029, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_TYPPRICE, __pyx_t_3) < 0) __PYX_ERR(3, 5029, __pyx_L1_error) + #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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 5062, __pyx_L1_error) + __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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 5062, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5062, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5060, __pyx_L1_error) + __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_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(3, 5060, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_18)) __PYX_ERR(3, 5060, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_2)) __PYX_ERR(3, 5060, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_18 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_325ULTOSC, 0, __pyx_n_s_ULTOSC, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__235)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5060, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __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); + #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_d, __pyx_n_s_ULTOSC, __pyx_t_2) < 0) __PYX_ERR(3, 5060, __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_ULTOSC, __pyx_t_4) < (0)) __PYX_ERR(4, 5162, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5097, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5097, __pyx_L1_error) + __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_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 5095, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_2)) __PYX_ERR(3, 5095, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_6)) __PYX_ERR(3, 5095, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_327VAR, 0, __pyx_n_s_VAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__236)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5095, __pyx_L1_error) + __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_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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_VAR, __pyx_t_6) < 0) __PYX_ERR(3, 5095, __pyx_L1_error) + #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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_329WCLPRICE, 0, __pyx_n_s_WCLPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__237)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5127, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_WCLPRICE, __pyx_t_6) < 0) __PYX_ERR(3, 5127, __pyx_L1_error) + #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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5160, __pyx_L1_error) + __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_18 = PyTuple_New(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 5158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_6)) __PYX_ERR(3, 5158, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_331WILLR, 0, __pyx_n_s_WILLR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__238)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5158, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_WILLR, __pyx_t_6) < 0) __PYX_ERR(3, 5158, __pyx_L1_error) + #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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5193, __pyx_L1_error) + __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_18 = PyTuple_New(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 5191, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_6)) __PYX_ERR(3, 5191, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_333WMA, 0, __pyx_n_s_WMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__239)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5191, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_WMA, __pyx_t_6) < 0) __PYX_ERR(3, 5191, __pyx_L1_error) + #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_6 = PyList_New(158); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5222, __pyx_L1_error) + __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); - __Pyx_INCREF(__pyx_n_s_ACOS); - __Pyx_GIVEREF(__pyx_n_s_ACOS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_n_s_ACOS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_AD); - __Pyx_GIVEREF(__pyx_n_s_AD); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_AD)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ADD); - __Pyx_GIVEREF(__pyx_n_s_ADD); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_n_s_ADD)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ADOSC); - __Pyx_GIVEREF(__pyx_n_s_ADOSC); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 3, __pyx_n_s_ADOSC)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ADX); - __Pyx_GIVEREF(__pyx_n_s_ADX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 4, __pyx_n_s_ADX)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ADXR); - __Pyx_GIVEREF(__pyx_n_s_ADXR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 5, __pyx_n_s_ADXR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_APO); - __Pyx_GIVEREF(__pyx_n_s_APO); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 6, __pyx_n_s_APO)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_AROON); - __Pyx_GIVEREF(__pyx_n_s_AROON); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 7, __pyx_n_s_AROON)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_AROONOSC); - __Pyx_GIVEREF(__pyx_n_s_AROONOSC); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 8, __pyx_n_s_AROONOSC)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ASIN); - __Pyx_GIVEREF(__pyx_n_s_ASIN); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 9, __pyx_n_s_ASIN)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ATAN); - __Pyx_GIVEREF(__pyx_n_s_ATAN); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 10, __pyx_n_s_ATAN)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ATR); - __Pyx_GIVEREF(__pyx_n_s_ATR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 11, __pyx_n_s_ATR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_AVGPRICE); - __Pyx_GIVEREF(__pyx_n_s_AVGPRICE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 12, __pyx_n_s_AVGPRICE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_BBANDS); - __Pyx_GIVEREF(__pyx_n_s_BBANDS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 13, __pyx_n_s_BBANDS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_BETA); - __Pyx_GIVEREF(__pyx_n_s_BETA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 14, __pyx_n_s_BETA)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_BOP); - __Pyx_GIVEREF(__pyx_n_s_BOP); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 15, __pyx_n_s_BOP)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CCI); - __Pyx_GIVEREF(__pyx_n_s_CCI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 16, __pyx_n_s_CCI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDL2CROWS); - __Pyx_GIVEREF(__pyx_n_s_CDL2CROWS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 17, __pyx_n_s_CDL2CROWS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDL3BLACKCROWS); - __Pyx_GIVEREF(__pyx_n_s_CDL3BLACKCROWS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 18, __pyx_n_s_CDL3BLACKCROWS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDL3INSIDE); - __Pyx_GIVEREF(__pyx_n_s_CDL3INSIDE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 19, __pyx_n_s_CDL3INSIDE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDL3LINESTRIKE); - __Pyx_GIVEREF(__pyx_n_s_CDL3LINESTRIKE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 20, __pyx_n_s_CDL3LINESTRIKE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDL3OUTSIDE); - __Pyx_GIVEREF(__pyx_n_s_CDL3OUTSIDE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 21, __pyx_n_s_CDL3OUTSIDE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDL3STARSINSOUTH); - __Pyx_GIVEREF(__pyx_n_s_CDL3STARSINSOUTH); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 22, __pyx_n_s_CDL3STARSINSOUTH)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDL3WHITESOLDIERS); - __Pyx_GIVEREF(__pyx_n_s_CDL3WHITESOLDIERS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 23, __pyx_n_s_CDL3WHITESOLDIERS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLABANDONEDBABY); - __Pyx_GIVEREF(__pyx_n_s_CDLABANDONEDBABY); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 24, __pyx_n_s_CDLABANDONEDBABY)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLADVANCEBLOCK); - __Pyx_GIVEREF(__pyx_n_s_CDLADVANCEBLOCK); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 25, __pyx_n_s_CDLADVANCEBLOCK)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLBELTHOLD); - __Pyx_GIVEREF(__pyx_n_s_CDLBELTHOLD); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 26, __pyx_n_s_CDLBELTHOLD)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLBREAKAWAY); - __Pyx_GIVEREF(__pyx_n_s_CDLBREAKAWAY); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 27, __pyx_n_s_CDLBREAKAWAY)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLCLOSINGMARUBOZU); - __Pyx_GIVEREF(__pyx_n_s_CDLCLOSINGMARUBOZU); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 28, __pyx_n_s_CDLCLOSINGMARUBOZU)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLCONCEALBABYSWALL); - __Pyx_GIVEREF(__pyx_n_s_CDLCONCEALBABYSWALL); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 29, __pyx_n_s_CDLCONCEALBABYSWALL)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLCOUNTERATTACK); - __Pyx_GIVEREF(__pyx_n_s_CDLCOUNTERATTACK); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 30, __pyx_n_s_CDLCOUNTERATTACK)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLDARKCLOUDCOVER); - __Pyx_GIVEREF(__pyx_n_s_CDLDARKCLOUDCOVER); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 31, __pyx_n_s_CDLDARKCLOUDCOVER)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLDOJI); - __Pyx_GIVEREF(__pyx_n_s_CDLDOJI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 32, __pyx_n_s_CDLDOJI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLDOJISTAR); - __Pyx_GIVEREF(__pyx_n_s_CDLDOJISTAR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 33, __pyx_n_s_CDLDOJISTAR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLDRAGONFLYDOJI); - __Pyx_GIVEREF(__pyx_n_s_CDLDRAGONFLYDOJI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 34, __pyx_n_s_CDLDRAGONFLYDOJI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLENGULFING); - __Pyx_GIVEREF(__pyx_n_s_CDLENGULFING); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 35, __pyx_n_s_CDLENGULFING)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLEVENINGDOJISTAR); - __Pyx_GIVEREF(__pyx_n_s_CDLEVENINGDOJISTAR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 36, __pyx_n_s_CDLEVENINGDOJISTAR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLEVENINGSTAR); - __Pyx_GIVEREF(__pyx_n_s_CDLEVENINGSTAR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 37, __pyx_n_s_CDLEVENINGSTAR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLGAPSIDESIDEWHITE); - __Pyx_GIVEREF(__pyx_n_s_CDLGAPSIDESIDEWHITE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 38, __pyx_n_s_CDLGAPSIDESIDEWHITE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLGRAVESTONEDOJI); - __Pyx_GIVEREF(__pyx_n_s_CDLGRAVESTONEDOJI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 39, __pyx_n_s_CDLGRAVESTONEDOJI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLHAMMER); - __Pyx_GIVEREF(__pyx_n_s_CDLHAMMER); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 40, __pyx_n_s_CDLHAMMER)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLHANGINGMAN); - __Pyx_GIVEREF(__pyx_n_s_CDLHANGINGMAN); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 41, __pyx_n_s_CDLHANGINGMAN)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLHARAMI); - __Pyx_GIVEREF(__pyx_n_s_CDLHARAMI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 42, __pyx_n_s_CDLHARAMI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLHARAMICROSS); - __Pyx_GIVEREF(__pyx_n_s_CDLHARAMICROSS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 43, __pyx_n_s_CDLHARAMICROSS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLHIGHWAVE); - __Pyx_GIVEREF(__pyx_n_s_CDLHIGHWAVE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 44, __pyx_n_s_CDLHIGHWAVE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLHIKKAKE); - __Pyx_GIVEREF(__pyx_n_s_CDLHIKKAKE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 45, __pyx_n_s_CDLHIKKAKE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLHIKKAKEMOD); - __Pyx_GIVEREF(__pyx_n_s_CDLHIKKAKEMOD); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 46, __pyx_n_s_CDLHIKKAKEMOD)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLHOMINGPIGEON); - __Pyx_GIVEREF(__pyx_n_s_CDLHOMINGPIGEON); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 47, __pyx_n_s_CDLHOMINGPIGEON)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLIDENTICAL3CROWS); - __Pyx_GIVEREF(__pyx_n_s_CDLIDENTICAL3CROWS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 48, __pyx_n_s_CDLIDENTICAL3CROWS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLINNECK); - __Pyx_GIVEREF(__pyx_n_s_CDLINNECK); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 49, __pyx_n_s_CDLINNECK)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLINVERTEDHAMMER); - __Pyx_GIVEREF(__pyx_n_s_CDLINVERTEDHAMMER); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 50, __pyx_n_s_CDLINVERTEDHAMMER)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLKICKING); - __Pyx_GIVEREF(__pyx_n_s_CDLKICKING); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 51, __pyx_n_s_CDLKICKING)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLKICKINGBYLENGTH); - __Pyx_GIVEREF(__pyx_n_s_CDLKICKINGBYLENGTH); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 52, __pyx_n_s_CDLKICKINGBYLENGTH)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLLADDERBOTTOM); - __Pyx_GIVEREF(__pyx_n_s_CDLLADDERBOTTOM); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 53, __pyx_n_s_CDLLADDERBOTTOM)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLLONGLEGGEDDOJI); - __Pyx_GIVEREF(__pyx_n_s_CDLLONGLEGGEDDOJI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 54, __pyx_n_s_CDLLONGLEGGEDDOJI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLLONGLINE); - __Pyx_GIVEREF(__pyx_n_s_CDLLONGLINE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 55, __pyx_n_s_CDLLONGLINE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLMARUBOZU); - __Pyx_GIVEREF(__pyx_n_s_CDLMARUBOZU); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 56, __pyx_n_s_CDLMARUBOZU)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLMATCHINGLOW); - __Pyx_GIVEREF(__pyx_n_s_CDLMATCHINGLOW); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 57, __pyx_n_s_CDLMATCHINGLOW)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLMATHOLD); - __Pyx_GIVEREF(__pyx_n_s_CDLMATHOLD); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 58, __pyx_n_s_CDLMATHOLD)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLMORNINGDOJISTAR); - __Pyx_GIVEREF(__pyx_n_s_CDLMORNINGDOJISTAR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 59, __pyx_n_s_CDLMORNINGDOJISTAR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLMORNINGSTAR); - __Pyx_GIVEREF(__pyx_n_s_CDLMORNINGSTAR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 60, __pyx_n_s_CDLMORNINGSTAR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLONNECK); - __Pyx_GIVEREF(__pyx_n_s_CDLONNECK); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 61, __pyx_n_s_CDLONNECK)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLPIERCING); - __Pyx_GIVEREF(__pyx_n_s_CDLPIERCING); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 62, __pyx_n_s_CDLPIERCING)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLRICKSHAWMAN); - __Pyx_GIVEREF(__pyx_n_s_CDLRICKSHAWMAN); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 63, __pyx_n_s_CDLRICKSHAWMAN)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLRISEFALL3METHODS); - __Pyx_GIVEREF(__pyx_n_s_CDLRISEFALL3METHODS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 64, __pyx_n_s_CDLRISEFALL3METHODS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLSEPARATINGLINES); - __Pyx_GIVEREF(__pyx_n_s_CDLSEPARATINGLINES); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 65, __pyx_n_s_CDLSEPARATINGLINES)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLSHOOTINGSTAR); - __Pyx_GIVEREF(__pyx_n_s_CDLSHOOTINGSTAR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 66, __pyx_n_s_CDLSHOOTINGSTAR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLSHORTLINE); - __Pyx_GIVEREF(__pyx_n_s_CDLSHORTLINE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 67, __pyx_n_s_CDLSHORTLINE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLSPINNINGTOP); - __Pyx_GIVEREF(__pyx_n_s_CDLSPINNINGTOP); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 68, __pyx_n_s_CDLSPINNINGTOP)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLSTALLEDPATTERN); - __Pyx_GIVEREF(__pyx_n_s_CDLSTALLEDPATTERN); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 69, __pyx_n_s_CDLSTALLEDPATTERN)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLSTICKSANDWICH); - __Pyx_GIVEREF(__pyx_n_s_CDLSTICKSANDWICH); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 70, __pyx_n_s_CDLSTICKSANDWICH)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLTAKURI); - __Pyx_GIVEREF(__pyx_n_s_CDLTAKURI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 71, __pyx_n_s_CDLTAKURI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLTASUKIGAP); - __Pyx_GIVEREF(__pyx_n_s_CDLTASUKIGAP); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 72, __pyx_n_s_CDLTASUKIGAP)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLTHRUSTING); - __Pyx_GIVEREF(__pyx_n_s_CDLTHRUSTING); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 73, __pyx_n_s_CDLTHRUSTING)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLTRISTAR); - __Pyx_GIVEREF(__pyx_n_s_CDLTRISTAR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 74, __pyx_n_s_CDLTRISTAR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLUNIQUE3RIVER); - __Pyx_GIVEREF(__pyx_n_s_CDLUNIQUE3RIVER); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 75, __pyx_n_s_CDLUNIQUE3RIVER)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLUPSIDEGAP2CROWS); - __Pyx_GIVEREF(__pyx_n_s_CDLUPSIDEGAP2CROWS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 76, __pyx_n_s_CDLUPSIDEGAP2CROWS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CDLXSIDEGAP3METHODS); - __Pyx_GIVEREF(__pyx_n_s_CDLXSIDEGAP3METHODS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 77, __pyx_n_s_CDLXSIDEGAP3METHODS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CEIL); - __Pyx_GIVEREF(__pyx_n_s_CEIL); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 78, __pyx_n_s_CEIL)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CMO); - __Pyx_GIVEREF(__pyx_n_s_CMO); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 79, __pyx_n_s_CMO)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CORREL); - __Pyx_GIVEREF(__pyx_n_s_CORREL); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 80, __pyx_n_s_CORREL)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_COS); - __Pyx_GIVEREF(__pyx_n_s_COS); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 81, __pyx_n_s_COS)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_COSH); - __Pyx_GIVEREF(__pyx_n_s_COSH); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 82, __pyx_n_s_COSH)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_DEMA); - __Pyx_GIVEREF(__pyx_n_s_DEMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 83, __pyx_n_s_DEMA)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_DIV); - __Pyx_GIVEREF(__pyx_n_s_DIV); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 84, __pyx_n_s_DIV)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_DX); - __Pyx_GIVEREF(__pyx_n_s_DX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 85, __pyx_n_s_DX)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_EMA); - __Pyx_GIVEREF(__pyx_n_s_EMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 86, __pyx_n_s_EMA)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_EXP); - __Pyx_GIVEREF(__pyx_n_s_EXP); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 87, __pyx_n_s_EXP)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_FLOOR); - __Pyx_GIVEREF(__pyx_n_s_FLOOR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 88, __pyx_n_s_FLOOR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_DCPERIOD); - __Pyx_GIVEREF(__pyx_n_s_HT_DCPERIOD); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 89, __pyx_n_s_HT_DCPERIOD)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_DCPHASE); - __Pyx_GIVEREF(__pyx_n_s_HT_DCPHASE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 90, __pyx_n_s_HT_DCPHASE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_PHASOR); - __Pyx_GIVEREF(__pyx_n_s_HT_PHASOR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 91, __pyx_n_s_HT_PHASOR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_SINE); - __Pyx_GIVEREF(__pyx_n_s_HT_SINE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 92, __pyx_n_s_HT_SINE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_TRENDLINE); - __Pyx_GIVEREF(__pyx_n_s_HT_TRENDLINE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 93, __pyx_n_s_HT_TRENDLINE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_HT_TRENDMODE); - __Pyx_GIVEREF(__pyx_n_s_HT_TRENDMODE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 94, __pyx_n_s_HT_TRENDMODE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_KAMA); - __Pyx_GIVEREF(__pyx_n_s_KAMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 95, __pyx_n_s_KAMA)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_LINEARREG); - __Pyx_GIVEREF(__pyx_n_s_LINEARREG); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 96, __pyx_n_s_LINEARREG)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_LINEARREG_ANGLE); - __Pyx_GIVEREF(__pyx_n_s_LINEARREG_ANGLE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 97, __pyx_n_s_LINEARREG_ANGLE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_LINEARREG_INTERCEPT); - __Pyx_GIVEREF(__pyx_n_s_LINEARREG_INTERCEPT); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 98, __pyx_n_s_LINEARREG_INTERCEPT)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_LINEARREG_SLOPE); - __Pyx_GIVEREF(__pyx_n_s_LINEARREG_SLOPE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 99, __pyx_n_s_LINEARREG_SLOPE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_LN); - __Pyx_GIVEREF(__pyx_n_s_LN); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 100, __pyx_n_s_LN)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_LOG10); - __Pyx_GIVEREF(__pyx_n_s_LOG10); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 101, __pyx_n_s_LOG10)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MA); - __Pyx_GIVEREF(__pyx_n_s_MA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 102, __pyx_n_s_MA)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MACD); - __Pyx_GIVEREF(__pyx_n_s_MACD); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 103, __pyx_n_s_MACD)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MACDEXT); - __Pyx_GIVEREF(__pyx_n_s_MACDEXT); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 104, __pyx_n_s_MACDEXT)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MACDFIX); - __Pyx_GIVEREF(__pyx_n_s_MACDFIX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 105, __pyx_n_s_MACDFIX)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MAMA); - __Pyx_GIVEREF(__pyx_n_s_MAMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 106, __pyx_n_s_MAMA)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MAVP); - __Pyx_GIVEREF(__pyx_n_s_MAVP); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 107, __pyx_n_s_MAVP)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MAX); - __Pyx_GIVEREF(__pyx_n_s_MAX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 108, __pyx_n_s_MAX)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MAXINDEX); - __Pyx_GIVEREF(__pyx_n_s_MAXINDEX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 109, __pyx_n_s_MAXINDEX)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MEDPRICE); - __Pyx_GIVEREF(__pyx_n_s_MEDPRICE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 110, __pyx_n_s_MEDPRICE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MFI); - __Pyx_GIVEREF(__pyx_n_s_MFI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 111, __pyx_n_s_MFI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MIDPOINT); - __Pyx_GIVEREF(__pyx_n_s_MIDPOINT); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 112, __pyx_n_s_MIDPOINT)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MIDPRICE); - __Pyx_GIVEREF(__pyx_n_s_MIDPRICE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 113, __pyx_n_s_MIDPRICE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MIN); - __Pyx_GIVEREF(__pyx_n_s_MIN); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 114, __pyx_n_s_MIN)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MININDEX); - __Pyx_GIVEREF(__pyx_n_s_MININDEX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 115, __pyx_n_s_MININDEX)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MINMAX); - __Pyx_GIVEREF(__pyx_n_s_MINMAX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 116, __pyx_n_s_MINMAX)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MINMAXINDEX); - __Pyx_GIVEREF(__pyx_n_s_MINMAXINDEX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 117, __pyx_n_s_MINMAXINDEX)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MINUS_DI); - __Pyx_GIVEREF(__pyx_n_s_MINUS_DI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 118, __pyx_n_s_MINUS_DI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MINUS_DM); - __Pyx_GIVEREF(__pyx_n_s_MINUS_DM); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 119, __pyx_n_s_MINUS_DM)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MOM); - __Pyx_GIVEREF(__pyx_n_s_MOM); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 120, __pyx_n_s_MOM)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_MULT); - __Pyx_GIVEREF(__pyx_n_s_MULT); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 121, __pyx_n_s_MULT)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_NATR); - __Pyx_GIVEREF(__pyx_n_s_NATR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 122, __pyx_n_s_NATR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_OBV); - __Pyx_GIVEREF(__pyx_n_s_OBV); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 123, __pyx_n_s_OBV)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_PLUS_DI); - __Pyx_GIVEREF(__pyx_n_s_PLUS_DI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 124, __pyx_n_s_PLUS_DI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_PLUS_DM); - __Pyx_GIVEREF(__pyx_n_s_PLUS_DM); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 125, __pyx_n_s_PLUS_DM)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_PPO); - __Pyx_GIVEREF(__pyx_n_s_PPO); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 126, __pyx_n_s_PPO)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ROC); - __Pyx_GIVEREF(__pyx_n_s_ROC); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 127, __pyx_n_s_ROC)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ROCP); - __Pyx_GIVEREF(__pyx_n_s_ROCP); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 128, __pyx_n_s_ROCP)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ROCR); - __Pyx_GIVEREF(__pyx_n_s_ROCR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 129, __pyx_n_s_ROCR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ROCR100); - __Pyx_GIVEREF(__pyx_n_s_ROCR100); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 130, __pyx_n_s_ROCR100)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_RSI); - __Pyx_GIVEREF(__pyx_n_s_RSI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 131, __pyx_n_s_RSI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_SAR); - __Pyx_GIVEREF(__pyx_n_s_SAR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 132, __pyx_n_s_SAR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_SAREXT); - __Pyx_GIVEREF(__pyx_n_s_SAREXT); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 133, __pyx_n_s_SAREXT)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_SIN); - __Pyx_GIVEREF(__pyx_n_s_SIN); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 134, __pyx_n_s_SIN)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_SINH); - __Pyx_GIVEREF(__pyx_n_s_SINH); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 135, __pyx_n_s_SINH)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_SMA); - __Pyx_GIVEREF(__pyx_n_s_SMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 136, __pyx_n_s_SMA)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_SQRT); - __Pyx_GIVEREF(__pyx_n_s_SQRT); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 137, __pyx_n_s_SQRT)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_STDDEV); - __Pyx_GIVEREF(__pyx_n_s_STDDEV); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 138, __pyx_n_s_STDDEV)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_STOCH); - __Pyx_GIVEREF(__pyx_n_s_STOCH); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 139, __pyx_n_s_STOCH)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_STOCHF); - __Pyx_GIVEREF(__pyx_n_s_STOCHF); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 140, __pyx_n_s_STOCHF)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_STOCHRSI); - __Pyx_GIVEREF(__pyx_n_s_STOCHRSI); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 141, __pyx_n_s_STOCHRSI)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_SUB); - __Pyx_GIVEREF(__pyx_n_s_SUB); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 142, __pyx_n_s_SUB)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_SUM); - __Pyx_GIVEREF(__pyx_n_s_SUM); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 143, __pyx_n_s_SUM)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_T3); - __Pyx_GIVEREF(__pyx_n_s_T3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 144, __pyx_n_s_T3)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_TAN); - __Pyx_GIVEREF(__pyx_n_s_TAN); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 145, __pyx_n_s_TAN)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_TANH); - __Pyx_GIVEREF(__pyx_n_s_TANH); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 146, __pyx_n_s_TANH)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_TEMA); - __Pyx_GIVEREF(__pyx_n_s_TEMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 147, __pyx_n_s_TEMA)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_TRANGE); - __Pyx_GIVEREF(__pyx_n_s_TRANGE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 148, __pyx_n_s_TRANGE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_TRIMA); - __Pyx_GIVEREF(__pyx_n_s_TRIMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 149, __pyx_n_s_TRIMA)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_TRIX); - __Pyx_GIVEREF(__pyx_n_s_TRIX); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 150, __pyx_n_s_TRIX)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_TSF); - __Pyx_GIVEREF(__pyx_n_s_TSF); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 151, __pyx_n_s_TSF)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_TYPPRICE); - __Pyx_GIVEREF(__pyx_n_s_TYPPRICE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 152, __pyx_n_s_TYPPRICE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ULTOSC); - __Pyx_GIVEREF(__pyx_n_s_ULTOSC); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 153, __pyx_n_s_ULTOSC)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_VAR); - __Pyx_GIVEREF(__pyx_n_s_VAR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 154, __pyx_n_s_VAR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_WCLPRICE); - __Pyx_GIVEREF(__pyx_n_s_WCLPRICE); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 155, __pyx_n_s_WCLPRICE)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_WILLR); - __Pyx_GIVEREF(__pyx_n_s_WILLR); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 156, __pyx_n_s_WILLR)) __PYX_ERR(3, 5222, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_WMA); - __Pyx_GIVEREF(__pyx_n_s_WMA); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 157, __pyx_n_s_WMA)) __PYX_ERR(3, 5222, __pyx_L1_error); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TA_FUNCTION_NAMES, __pyx_t_6) < 0) __PYX_ERR(3, 5222, __pyx_L1_error) + 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_6 = __Pyx_ImportDottedModuleRelFirst(__pyx_n_s_math, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 4, __pyx_L1_error) + __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_d, __pyx_n_s_math, __pyx_t_6) < 0) __PYX_ERR(1, 4, __pyx_L1_error) + 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_6 = __Pyx_ImportDottedModuleRelFirst(__pyx_n_s_threading, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 5, __pyx_L1_error) + __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_d, __pyx_n_s_threading, __pyx_t_6) < 0) __PYX_ERR(1, 5, __pyx_L1_error) + 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 __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_23, &__pyx_t_24); + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_24, &__pyx_t_25); __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_23); __Pyx_XGOTREF(__pyx_t_24); + __Pyx_XGOTREF(__pyx_t_25); /*try:*/ { - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 7, __pyx_L11_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__pyx_n_s_OrderedDict); - __Pyx_GIVEREF(__pyx_n_s_OrderedDict); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_n_s_OrderedDict)) __PYX_ERR(1, 7, __pyx_L11_error); - __pyx_t_18 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_6, -1); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 7, __pyx_L11_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_18, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 7, __pyx_L11_error) + { + 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); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_OrderedDict, __pyx_t_6) < 0) __PYX_ERR(1, 7, __pyx_L11_error) + { + 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_DECREF(__pyx_t_18); __pyx_t_18 = 0; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0; + __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0; goto __pyx_L16_try_end; __pyx_L11_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; @@ -99099,150 +83514,152 @@ if (!__Pyx_RefNanny) { __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 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_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_22 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError); - if (__pyx_t_22) { + __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_18, &__pyx_t_6, &__pyx_t_2) < 0) __PYX_ERR(1, 8, __pyx_L13_except_error) - __Pyx_XGOTREF(__pyx_t_18); + 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_2); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_4); - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L13_except_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_n_s_OrderedDict); - __Pyx_GIVEREF(__pyx_n_s_OrderedDict); - if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_OrderedDict)) __PYX_ERR(1, 9, __pyx_L13_except_error); - __pyx_t_14 = __Pyx_Import(__pyx_n_s_ordereddict, __pyx_t_3, -1); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 9, __pyx_L13_except_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_14, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L13_except_error) + { + 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); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_OrderedDict, __pyx_t_3) < 0) __PYX_ERR(1, 9, __pyx_L13_except_error) + { + 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_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L12_exception_handled; } goto __pyx_L13_except_error; __pyx_L13_except_error:; __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_24); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_23, __pyx_t_24); + __Pyx_XGIVEREF(__pyx_t_25); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25); goto __pyx_L1_error; __pyx_L12_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_24); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_23, __pyx_t_24); + __Pyx_XGIVEREF(__pyx_t_25); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25); __pyx_L16_try_end:; } - __pyx_t_2 = __Pyx_ImportDottedModuleRelFirst(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 11, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_2) < 0) __PYX_ERR(1, 11, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_ImportDottedModuleRelFirst(__pyx_n_s_sys, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_2) < 0) __PYX_ERR(1, 12, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_price, __pyx_n_s_close) < 0) __PYX_ERR(1, 20, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_price0, __pyx_n_s_high) < 0) __PYX_ERR(1, 20, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_price1, __pyx_n_s_low) < 0) __PYX_ERR(1, 20, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_periods, __pyx_n_s_periods) < 0) __PYX_ERR(1, 20, __pyx_L1_error) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS, __pyx_t_2) < 0) __PYX_ERR(1, 20, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF((PyObject *)(&PyDict_Type)); - __Pyx_GIVEREF((PyObject *)(&PyDict_Type)); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, ((PyObject *)(&PyDict_Type)))) __PYX_ERR(1, 26, __pyx_L1_error); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INPUT_ARRAYS_TYPES, __pyx_t_2) < 0) __PYX_ERR(1, 26, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF((PyObject *)__pyx_ptype_5numpy_ndarray); - __Pyx_GIVEREF((PyObject *)__pyx_ptype_5numpy_ndarray); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_ptype_5numpy_ndarray))) __PYX_ERR(1, 27, __pyx_L1_error); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARRAY_TYPES, __pyx_t_2) < 0) __PYX_ERR(1, 27, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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) + __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) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_24, &__pyx_t_23, &__pyx_t_1); + __Pyx_ExceptionSave(&__pyx_t_25, &__pyx_t_24, &__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_25); __Pyx_XGOTREF(__pyx_t_24); - __Pyx_XGOTREF(__pyx_t_23); __Pyx_XGOTREF(__pyx_t_1); /*try:*/ { - __pyx_t_2 = __Pyx_ImportDottedModuleRelFirst(__pyx_n_s_pandas, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 31, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pandas, __pyx_t_2) < 0) __PYX_ERR(1, 31, __pyx_L19_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 32, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_pandas); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 32, __pyx_L19_error) + __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_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_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_DataFrame); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 32, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_18); + __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_6); __pyx_t_6 = 0; - __pyx_t_25 = __Pyx_PyObject_Append(__pyx_t_2, __pyx_t_18); if (unlikely(__pyx_t_25 == ((int)-1))) __PYX_ERR(1, 32, __pyx_L19_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_ARRAY_TYPES); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 33, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_pandas); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 33, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Series); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 33, __pyx_L19_error) + __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_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_25 = __Pyx_PyObject_Append(__pyx_t_18, __pyx_t_6); if (unlikely(__pyx_t_25 == ((int)-1))) __PYX_ERR(1, 33, __pyx_L19_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_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_6, __pyx_n_s_pandas); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 34, __pyx_L19_error) + __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_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_DataFrame); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 34, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_18); + __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_PANDAS_DATAFRAME, __pyx_t_18) < 0) __PYX_ERR(1, 34, __pyx_L19_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_pandas); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 35, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_Series); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 35, __pyx_L19_error) + __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_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_PANDAS_SERIES, __pyx_t_6) < 0) __PYX_ERR(1, 35, __pyx_L19_error) + __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; __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0; - __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L24_try_end; __pyx_L19_error:; @@ -99252,2370 +83669,5098 @@ if (!__Pyx_RefNanny) { __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 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_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_22 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError); - if (__pyx_t_22) { + __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_6, &__pyx_t_18, &__pyx_t_2) < 0) __PYX_ERR(1, 36, __pyx_L21_except_error) + 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_18); - __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + 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_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_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_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_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_30 = __pyx_t_32; + __pyx_L36_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, 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_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; + __pyx_L27_error:; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 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_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_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_NameError)))); + if (__pyx_t_23) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L28_exception_handled; + } + goto __pyx_L29_except_error; + + __pyx_L29_except_error:; + __Pyx_XGIVEREF(__pyx_t_26); + __Pyx_XGIVEREF(__pyx_t_28); + __Pyx_XGIVEREF(__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_26); + __Pyx_XGIVEREF(__pyx_t_28); + __Pyx_XGIVEREF(__pyx_t_29); + __Pyx_ExceptionReset(__pyx_t_26, __pyx_t_28, __pyx_t_29); + __pyx_L34_try_end:; + } - if (PyDict_SetItem(__pyx_d, __pyx_n_s_PANDAS_DATAFRAME, Py_None) < 0) __PYX_ERR(1, 37, __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_d, __pyx_n_s_PANDAS_SERIES, Py_None) < 0) __PYX_ERR(1, 38, __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_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L20_exception_handled; } goto __pyx_L21_except_error; __pyx_L21_except_error:; + __Pyx_XGIVEREF(__pyx_t_25); __Pyx_XGIVEREF(__pyx_t_24); - __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_ExceptionReset(__pyx_t_24, __pyx_t_23, __pyx_t_1); + __Pyx_ExceptionReset(__pyx_t_25, __pyx_t_24, __pyx_t_1); goto __pyx_L1_error; __pyx_L20_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_25); __Pyx_XGIVEREF(__pyx_t_24); - __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_ExceptionReset(__pyx_t_24, __pyx_t_23, __pyx_t_1); + __Pyx_ExceptionReset(__pyx_t_25, __pyx_t_24, __pyx_t_1); __pyx_L24_try_end:; } { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_23, &__pyx_t_24); + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_24, &__pyx_t_25); __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_23); __Pyx_XGOTREF(__pyx_t_24); + __Pyx_XGOTREF(__pyx_t_25); /*try:*/ { - __pyx_t_2 = __Pyx_ImportDottedModuleRelFirst(__pyx_n_s_polars, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 42, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_polars, __pyx_t_2) < 0) __PYX_ERR(1, 42, __pyx_L27_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 43, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_polars); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 43, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_DataFrame); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 43, __pyx_L27_error) + __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_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_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __pyx_t_25 = __Pyx_PyObject_Append(__pyx_t_2, __pyx_t_6); if (unlikely(__pyx_t_25 == ((int)-1))) __PYX_ERR(1, 43, __pyx_L27_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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_19); __pyx_t_19 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ARRAY_TYPES); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 44, __pyx_L27_error) + __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_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_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_polars); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 44, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Series); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 44, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_25 = __Pyx_PyObject_Append(__pyx_t_6, __pyx_t_18); if (unlikely(__pyx_t_25 == ((int)-1))) __PYX_ERR(1, 44, __pyx_L27_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 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_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_polars); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 45, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_DataFrame); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 45, __pyx_L27_error) + __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_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_POLARS_DATAFRAME, __pyx_t_6) < 0) __PYX_ERR(1, 45, __pyx_L27_error) + __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_6, __pyx_n_s_polars); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 46, __pyx_L27_error) + __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_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_Series); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 46, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_18); + __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_POLARS_SERIES, __pyx_t_18) < 0) __PYX_ERR(1, 46, __pyx_L27_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0; - goto __pyx_L32_try_end; - __pyx_L27_error:; + __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0; + goto __pyx_L45_try_end; + __pyx_L40_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 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_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_22 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError); - if (__pyx_t_22) { + __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_18, &__pyx_t_6, &__pyx_t_2) < 0) __PYX_ERR(1, 47, __pyx_L29_except_error) - __Pyx_XGOTREF(__pyx_t_18); + 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_2); + __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_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_26); + __Pyx_XGOTREF(__pyx_t_29); + __Pyx_XGOTREF(__pyx_t_28); + __Pyx_XGOTREF(__pyx_t_26); + /*try:*/ { + + __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_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_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_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) + + } + + } + __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0; + __Pyx_XDECREF(__pyx_t_28); __pyx_t_28 = 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; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 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_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_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_NameError)))); + if (__pyx_t_23) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L49_exception_handled; + } + goto __pyx_L50_except_error; + + __pyx_L50_except_error:; + __Pyx_XGIVEREF(__pyx_t_29); + __Pyx_XGIVEREF(__pyx_t_28); + __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_26); + __Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_26); + __pyx_L55_try_end:; + } - if (PyDict_SetItem(__pyx_d, __pyx_n_s_POLARS_DATAFRAME, Py_None) < 0) __PYX_ERR(1, 48, __pyx_L29_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_d, __pyx_n_s_POLARS_SERIES, Py_None) < 0) __PYX_ERR(1, 49, __pyx_L29_except_error) - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 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_2); __pyx_t_2 = 0; - goto __pyx_L28_exception_handled; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L41_exception_handled; } - goto __pyx_L29_except_error; + goto __pyx_L42_except_error; - __pyx_L29_except_error:; + __pyx_L42_except_error:; __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_24); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_23, __pyx_t_24); + __Pyx_XGIVEREF(__pyx_t_25); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25); goto __pyx_L1_error; - __pyx_L28_exception_handled:; + __pyx_L41_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_24); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_23, __pyx_t_24); - __pyx_L32_try_end:; + __Pyx_XGIVEREF(__pyx_t_25); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25); + __pyx_L45_try_end:; } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 51, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PySequence_Tuple(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 51, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INPUT_ARRAYS_TYPES, __pyx_t_6) < 0) __PYX_ERR(1, 51, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_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_19) < (0)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ARRAY_TYPES); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARRAY_TYPES, __pyx_t_2) < 0) __PYX_ERR(1, 52, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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_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_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_version); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyObject_RichCompare(__pyx_t_6, __pyx_kp_s_3, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 55, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_26 < 0))) __PYX_ERR(1, 55, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (__pyx_t_26) { + __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_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_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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_335str2bytes, 0, __pyx_n_s_str2bytes, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__242)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_str2bytes, __pyx_t_2) < 0) __PYX_ERR(1, 57, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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 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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_337bytes2str, 0, __pyx_n_s_bytes2str, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__244)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_bytes2str, __pyx_t_2) < 0) __PYX_ERR(1, 60, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_L35; + goto __pyx_L61; } /*else*/ { - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_339str2bytes, 0, __pyx_n_s_str2bytes, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__245)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_str2bytes, __pyx_t_2) < 0) __PYX_ERR(1, 65, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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 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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_341bytes2str, 0, __pyx_n_s_bytes2str, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__246)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 68, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_bytes2str, __pyx_t_2) < 0) __PYX_ERR(1, 68, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_L35:; + __pyx_L61:; - __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_tuple__248); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 71, __pyx_L1_error) + __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_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); - __pyx_t_18 = __Pyx_Py3MetaclassPrepare(__pyx_t_6, __pyx_t_2, __pyx_n_s_Function, __pyx_n_s_Function, (PyObject *) NULL, __pyx_n_s_talib__ta_lib, __pyx_kp_s_This_is_a_pythonic_wrapper_arou); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - if (__pyx_t_2 != __pyx_tuple__248) { - if (unlikely((PyDict_SetItemString(__pyx_t_18, "__orig_bases__", __pyx_tuple__248) < 0))) __PYX_ERR(1, 71, __pyx_L1_error) + if (__pyx_t_4 != __pyx_mstate_global->__pyx_tuple[8]) { + 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_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_1__init__, 0, __pyx_n_s_Function___init, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__250)); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_init, __pyx_t_14) < 0) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - - __pyx_t_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_3__local, 0, __pyx_n_s_Function___local, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__252)); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 113, __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_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_Function__local, __pyx_t_3) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_5info, 0, __pyx_n_s_Function_info, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__253)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 155, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_14 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 155, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); + __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_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_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; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_info, __pyx_t_14) < 0) __PYX_ERR(1, 155, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __pyx_t_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_7function_flags, 0, __pyx_n_s_Function_function_flags, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__254)); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 162, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 162, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_function_flags, __pyx_t_3) < 0) __PYX_ERR(1, 162, __pyx_L1_error) + __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_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_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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_9output_flags, 0, __pyx_n_s_Function_output_flags, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__255)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_14 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); + __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_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_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; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_output_flags, __pyx_t_14) < 0) __PYX_ERR(1, 169, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __pyx_t_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_11get_input_names, 0, __pyx_n_s_Function_get_input_names, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__257)); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_get_input_names, __pyx_t_14) < 0) __PYX_ERR(1, 176, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __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_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_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_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_13set_input_names, 0, __pyx_n_s_Function_set_input_names, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__259)); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_set_input_names, __pyx_t_14) < 0) __PYX_ERR(1, 187, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 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_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_14 = PyObject_GetItem(__pyx_t_18, __pyx_n_s_get_input_names); - if (unlikely(!__pyx_t_14)) { + __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_14, __pyx_n_s_get_input_names); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_input_names); } - if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 197, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = PyObject_GetItem(__pyx_t_18, __pyx_n_s_set_input_names); - if (unlikely(!__pyx_t_3)) { + 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_3, __pyx_n_s_set_input_names); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_set_input_names); } - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 197, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 197, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_14)) __PYX_ERR(1, 197, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3)) __PYX_ERR(1, 197, __pyx_L1_error); - __pyx_t_14 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 197, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_input_names, __pyx_t_3) < 0) __PYX_ERR(1, 197, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = 1; + { + 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; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + 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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_15get_input_arrays, 0, __pyx_n_s_Function_get_input_arrays, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__261)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 199, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_get_input_arrays, __pyx_t_3) < 0) __PYX_ERR(1, 199, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays, 0, __pyx_n_s_Function_set_input_arrays, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__263)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 210, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_set_input_arrays, __pyx_t_3) < 0) __PYX_ERR(1, 210, __pyx_L1_error) + #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 = PyObject_GetItem(__pyx_t_18, __pyx_n_s_get_input_arrays); - if (unlikely(!__pyx_t_3)) { + __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_3, __pyx_n_s_get_input_arrays); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_input_arrays); } - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 257, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = PyObject_GetItem(__pyx_t_18, __pyx_n_s_set_input_arrays); - if (unlikely(!__pyx_t_7)) { + 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_7, __pyx_n_s_set_input_arrays); + __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_set_input_arrays); } - if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 257, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 257, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_3)) __PYX_ERR(1, 257, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_7)) __PYX_ERR(1, 257, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_14, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 257, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_input_arrays, __pyx_t_7) < 0) __PYX_ERR(1, 257, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_19get_parameters, 0, __pyx_n_s_Function_get_parameters, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__265)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 259, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_get_parameters, __pyx_t_7) < 0) __PYX_ERR(1, 259, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_21set_parameters, 0, __pyx_n_s_Function_set_parameters, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__267)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 269, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_tuple__268); - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_set_parameters, __pyx_t_7) < 0) __PYX_ERR(1, 269, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = PyObject_GetItem(__pyx_t_18, __pyx_n_s_get_parameters); - if (unlikely(!__pyx_t_7)) { + 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_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_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_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_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_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_7, __pyx_n_s_get_parameters); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_parameters); } - if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 282, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_14 = PyObject_GetItem(__pyx_t_18, __pyx_n_s_set_parameters); - if (unlikely(!__pyx_t_14)) { + 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_14, __pyx_n_s_set_parameters); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_set_parameters); } - if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 282, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 282, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7)) __PYX_ERR(1, 282, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_14)) __PYX_ERR(1, 282, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_14 = 0; - __pyx_t_14 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 282, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = 1; + { + 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; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + 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; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_parameters, __pyx_t_14) < 0) __PYX_ERR(1, 282, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - - __pyx_t_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args, 0, __pyx_n_s_Function_set_function_args, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__270)); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 284, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_set_function_args, __pyx_t_14) < 0) __PYX_ERR(1, 284, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __pyx_t_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_25lookback, 0, __pyx_n_s_Function_lookback, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__272)); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 319, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 319, __pyx_L1_error) + __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); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_lookback, __pyx_t_3) < 0) __PYX_ERR(1, 319, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_27output_names, 0, __pyx_n_s_Function_output_names, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__274)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 340, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_14 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 340, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); + __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_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_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; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_output_names, __pyx_t_14) < 0) __PYX_ERR(1, 340, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __pyx_t_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_29outputs, 0, __pyx_n_s_Function_outputs, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__276)); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 350, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 350, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_outputs, __pyx_t_3) < 0) __PYX_ERR(1, 350, __pyx_L1_error) + __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_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_3)) __PYX_ERR(2, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + 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_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_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, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + 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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_31run, 0, __pyx_n_s_Function_run, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__278)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 382, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__268); - if (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_run, __pyx_t_3) < 0) __PYX_ERR(1, 382, __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_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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_33__call__, 0, __pyx_n_s_Function___call, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__280)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 394, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_call, __pyx_t_3) < 0) __PYX_ERR(1, 394, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names, 0, __pyx_n_s_Function___input_price_series_na, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__282)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 460, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_Function__input_price_series_na, __pyx_t_3) < 0) __PYX_ERR(1, 460, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_37__call_function, 0, __pyx_n_s_Function___call_function, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__284)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 472, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_Function__call_function, __pyx_t_3) < 0) __PYX_ERR(1, 472, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value, 0, __pyx_n_s_Function___check_opt_input_value, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__286)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 503, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_Function__check_opt_input_value, __pyx_t_3) < 0) __PYX_ERR(1, 503, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value, 0, __pyx_n_s_Function___get_opt_input_value, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__288)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 518, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_Function__get_opt_input_value, __pyx_t_3) < 0) __PYX_ERR(1, 518, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_43__repr__, 0, __pyx_n_s_Function___repr, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__289)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 528, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_repr, __pyx_t_3) < 0) __PYX_ERR(1, 528, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__, 0, __pyx_n_s_Function___unicode, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__290)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 531, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_unicode, __pyx_t_3) < 0) __PYX_ERR(1, 531, __pyx_L1_error) + #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_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_47__str__, 0, __pyx_n_s_Function___str, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__291)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 534, __pyx_L1_error) + __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 (__Pyx_SetNameInClass(__pyx_t_18, __pyx_n_s_str, __pyx_t_3) < 0) __PYX_ERR(1, 534, __pyx_L1_error) + #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_3 = __Pyx_Py3ClassCreate(__pyx_t_6, __pyx_n_s_Function, __pyx_t_2, __pyx_t_18, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 71, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_Function, __pyx_t_3) < 0) __PYX_ERR(1, 71, __pyx_L1_error) + #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_18); __pyx_t_18 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_343_ta_getGroupTable, 0, __pyx_n_s_ta_getGroupTable, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__293)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 548, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getGroupTable, __pyx_t_2) < 0) __PYX_ERR(1, 548, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_345_ta_getFuncTable, 0, __pyx_n_s_ta_getFuncTable, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__295)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getFuncTable, __pyx_t_2) < 0) __PYX_ERR(1, 560, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_347__get_flags, 0, __pyx_n_s_get_flags, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__297)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_flags, __pyx_t_2) < 0) __PYX_ERR(1, 572, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 598, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_int_16777216, __pyx_kp_s_Output_scale_same_as_input) < 0) __PYX_ERR(1, 598, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_67108864, __pyx_kp_s_Output_is_over_volume) < 0) __PYX_ERR(1, 598, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_134217728, __pyx_kp_s_Function_has_an_unstable_period) < 0) __PYX_ERR(1, 598, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_268435456, __pyx_kp_s_Output_is_a_candlestick) < 0) __PYX_ERR(1, 598, __pyx_L1_error) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TA_FUNC_FLAGS, __pyx_t_2) < 0) __PYX_ERR(1, 597, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 606, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_int_1, __pyx_n_s_open) < 0) __PYX_ERR(1, 606, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_2, __pyx_n_s_high) < 0) __PYX_ERR(1, 606, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_4, __pyx_n_s_low) < 0) __PYX_ERR(1, 606, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_8, __pyx_n_s_close) < 0) __PYX_ERR(1, 606, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_16, __pyx_n_s_volume) < 0) __PYX_ERR(1, 606, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_32, __pyx_n_s_openInterest) < 0) __PYX_ERR(1, 606, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_64, __pyx_n_s_timeStamp) < 0) __PYX_ERR(1, 606, __pyx_L1_error) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TA_INPUT_FLAGS, __pyx_t_2) < 0) __PYX_ERR(1, 605, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 616, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_int_1, __pyx_n_s_Line) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_2, __pyx_kp_s_Dotted_Line) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_4, __pyx_kp_s_Dashed_Line) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_8, __pyx_n_s_Dot) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_16, __pyx_n_s_Histogram) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_32, __pyx_kp_s_Pattern_Bool) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_64, __pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_128, __pyx_kp_s_Strength_Pattern_200_100_Bearish) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_256, __pyx_kp_s_Output_can_be_positive) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_512, __pyx_kp_s_Output_can_be_negative) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_1024, __pyx_kp_s_Output_can_be_zero) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_2048, __pyx_kp_s_Values_represent_an_upper_limit) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_int_4096, __pyx_kp_s_Values_represent_a_lower_limit) < 0) __PYX_ERR(1, 616, __pyx_L1_error) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TA_OUTPUT_FLAGS, __pyx_t_2) < 0) __PYX_ERR(1, 615, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_349_ta_getFuncInfo, 0, __pyx_n_s_ta_getFuncInfo, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__299)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getFuncInfo, __pyx_t_2) < 0) __PYX_ERR(1, 631, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_351_ta_getInputParameterInfo, 0, __pyx_n_s_ta_getInputParameterInfo, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__301)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 650, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getInputParameterInfo, __pyx_t_2) < 0) __PYX_ERR(1, 650, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_353_ta_getOptInputParameterInfo, 0, __pyx_n_s_ta_getOptInputParameterInfo, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__303)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 671, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getOptInputParameterInfo, __pyx_t_2) < 0) __PYX_ERR(1, 671, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_355_ta_getOutputParameterInfo, 0, __pyx_n_s_ta_getOutputParameterInfo, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__304)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 695, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getOutputParameterInfo, __pyx_t_2) < 0) __PYX_ERR(1, 695, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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, 710, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_357_get_defaults_and_docs, 0, __pyx_n_s_get_defaults_and_docs, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__306)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 715, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_defaults_and_docs, __pyx_t_2) < 0) __PYX_ERR(1, 715, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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, 730, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_359stream_ACOS, 0, __pyx_n_s_stream_ACOS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__308)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ACOS, __pyx_t_2) < 0) __PYX_ERR(4, 9, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(5, 7, __pyx_L1_error) - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_361stream_AD, 0, __pyx_n_s_stream_AD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__310)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_AD, __pyx_t_2) < 0) __PYX_ERR(4, 36, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_363stream_ADD, 0, __pyx_n_s_stream_ADD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__312)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ADD, __pyx_t_2) < 0) __PYX_ERR(4, 72, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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); + #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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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 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_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_2)) __PYX_ERR(4, 103, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_6)) __PYX_ERR(4, 103, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_365stream_ADOSC, 0, __pyx_n_s_stream_ADOSC, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__314)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 103, __pyx_L1_error) + __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 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 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_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_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_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ADOSC, __pyx_t_6) < 0) __PYX_ERR(4, 103, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_18 = PyTuple_New(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_6)) __PYX_ERR(4, 142, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_367stream_ADX, 0, __pyx_n_s_stream_ADX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__316)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 142, __pyx_L1_error) + __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_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ADX, __pyx_t_6) < 0) __PYX_ERR(4, 142, __pyx_L1_error) + __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_18 = PyTuple_New(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_6)) __PYX_ERR(4, 177, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_369stream_ADXR, 0, __pyx_n_s_stream_ADXR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__317)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 177, __pyx_L1_error) + __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_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ADXR, __pyx_t_6) < 0) __PYX_ERR(4, 177, __pyx_L1_error) + __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 214, __pyx_L1_error) + __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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 214, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_2 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 214, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 212, __pyx_L1_error) + __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_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6)) __PYX_ERR(4, 212, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_18)) __PYX_ERR(4, 212, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(4, 212, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_18 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_371stream_APO, 0, __pyx_n_s_stream_APO, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__319)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __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); + #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_d, __pyx_n_s_stream_APO, __pyx_t_2) < 0) __PYX_ERR(4, 212, __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_APO, __pyx_t_4) < (0)) __PYX_ERR(5, 253, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 245, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 243, __pyx_L1_error) + __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_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(4, 243, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_373stream_AROON, 0, __pyx_n_s_stream_AROON, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__321)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __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); + #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_d, __pyx_n_s_stream_AROON, __pyx_t_2) < 0) __PYX_ERR(4, 243, __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_AROON, __pyx_t_4) < (0)) __PYX_ERR(5, 284, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 280, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 278, __pyx_L1_error) + __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_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(4, 278, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_375stream_AROONOSC, 0, __pyx_n_s_stream_AROONOSC, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__323)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 278, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __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); + #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_d, __pyx_n_s_stream_AROONOSC, __pyx_t_2) < 0) __PYX_ERR(4, 278, __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_AROONOSC, __pyx_t_4) < (0)) __PYX_ERR(5, 319, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_377stream_ASIN, 0, __pyx_n_s_stream_ASIN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__324)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 310, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ASIN, __pyx_t_2) < 0) __PYX_ERR(4, 310, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_379stream_ATAN, 0, __pyx_n_s_stream_ATAN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__325)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 337, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ATAN, __pyx_t_2) < 0) __PYX_ERR(4, 337, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 366, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 364, __pyx_L1_error) + __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_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(4, 364, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_381stream_ATR, 0, __pyx_n_s_stream_ATR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__326)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 364, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __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); + #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_d, __pyx_n_s_stream_ATR, __pyx_t_2) < 0) __PYX_ERR(4, 364, __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_ATR, __pyx_t_4) < (0)) __PYX_ERR(5, 405, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_383stream_AVGPRICE, 0, __pyx_n_s_stream_AVGPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__328)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 399, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_AVGPRICE, __pyx_t_2) < 0) __PYX_ERR(4, 399, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 437, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 437, __pyx_L1_error) + __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_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_t_18 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 437, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_6 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 437, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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); + #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_14 = PyTuple_New(4); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 435, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_2)) __PYX_ERR(4, 435, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_3)) __PYX_ERR(4, 435, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 2, __pyx_t_18)) __PYX_ERR(4, 435, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 3, __pyx_t_6)) __PYX_ERR(4, 435, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_18 = 0; - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_385stream_BBANDS, 0, __pyx_n_s_stream_BBANDS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__330)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 435, __pyx_L1_error) + __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_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_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_BBANDS, __pyx_t_6) < 0) __PYX_ERR(4, 435, __pyx_L1_error) + __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_3); __pyx_t_3 = 0; __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_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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 473, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_387stream_BETA, 0, __pyx_n_s_stream_BETA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__332)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_BETA, __pyx_t_6) < 0) __PYX_ERR(4, 473, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_389stream_BOP, 0, __pyx_n_s_stream_BOP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__333)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 506, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_BOP, __pyx_t_6) < 0) __PYX_ERR(4, 506, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 544, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 542, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 542, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_391stream_CCI, 0, __pyx_n_s_stream_CCI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__334)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 542, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CCI, __pyx_t_6) < 0) __PYX_ERR(4, 542, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_393stream_CDL2CROWS, 0, __pyx_n_s_stream_CDL2CROWS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__336)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL2CROWS, __pyx_t_6) < 0) __PYX_ERR(4, 577, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_395stream_CDL3BLACKCROWS, 0, __pyx_n_s_stream_CDL3BLACKCROWS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__337)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 613, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3BLACKCROWS, __pyx_t_6) < 0) __PYX_ERR(4, 613, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_397stream_CDL3INSIDE, 0, __pyx_n_s_stream_CDL3INSIDE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__338)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 649, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3INSIDE, __pyx_t_6) < 0) __PYX_ERR(4, 649, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_399stream_CDL3LINESTRIKE, 0, __pyx_n_s_stream_CDL3LINESTRIKE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__339)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 685, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3LINESTRIKE, __pyx_t_6) < 0) __PYX_ERR(4, 685, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_401stream_CDL3OUTSIDE, 0, __pyx_n_s_stream_CDL3OUTSIDE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__340)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 721, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3OUTSIDE, __pyx_t_6) < 0) __PYX_ERR(4, 721, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH, 0, __pyx_n_s_stream_CDL3STARSINSOUTH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__341)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 757, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3STARSINSOUTH, __pyx_t_6) < 0) __PYX_ERR(4, 757, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS, 0, __pyx_n_s_stream_CDL3WHITESOLDIERS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__342)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 793, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3WHITESOLDIERS, __pyx_t_6) < 0) __PYX_ERR(4, 793, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 831, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 829, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 829, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_407stream_CDLABANDONEDBABY, 0, __pyx_n_s_stream_CDLABANDONEDBABY, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__344)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 829, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLABANDONEDBABY, __pyx_t_6) < 0) __PYX_ERR(4, 829, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK, 0, __pyx_n_s_stream_CDLADVANCEBLOCK, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__345)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 867, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLADVANCEBLOCK, __pyx_t_6) < 0) __PYX_ERR(4, 867, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_411stream_CDLBELTHOLD, 0, __pyx_n_s_stream_CDLBELTHOLD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__346)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 903, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLBELTHOLD, __pyx_t_6) < 0) __PYX_ERR(4, 903, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_413stream_CDLBREAKAWAY, 0, __pyx_n_s_stream_CDLBREAKAWAY, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__347)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 939, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLBREAKAWAY, __pyx_t_6) < 0) __PYX_ERR(4, 939, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU, 0, __pyx_n_s_stream_CDLCLOSINGMARUBOZU, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__348)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 975, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLCLOSINGMARUBOZU, __pyx_t_6) < 0) __PYX_ERR(4, 975, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL, 0, __pyx_n_s_stream_CDLCONCEALBABYSWALL, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__349)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1011, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLCONCEALBABYSWALL, __pyx_t_6) < 0) __PYX_ERR(4, 1011, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK, 0, __pyx_n_s_stream_CDLCOUNTERATTACK, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__350)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1047, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLCOUNTERATTACK, __pyx_t_6) < 0) __PYX_ERR(4, 1047, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1085, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 1083, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 1083, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER, 0, __pyx_n_s_stream_CDLDARKCLOUDCOVER, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__351)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1083, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLDARKCLOUDCOVER, __pyx_t_6) < 0) __PYX_ERR(4, 1083, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_423stream_CDLDOJI, 0, __pyx_n_s_stream_CDLDOJI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__352)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLDOJI, __pyx_t_6) < 0) __PYX_ERR(4, 1121, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_425stream_CDLDOJISTAR, 0, __pyx_n_s_stream_CDLDOJISTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__353)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLDOJISTAR, __pyx_t_6) < 0) __PYX_ERR(4, 1157, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI, 0, __pyx_n_s_stream_CDLDRAGONFLYDOJI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__354)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLDRAGONFLYDOJI, __pyx_t_6) < 0) __PYX_ERR(4, 1193, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_429stream_CDLENGULFING, 0, __pyx_n_s_stream_CDLENGULFING, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__355)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLENGULFING, __pyx_t_6) < 0) __PYX_ERR(4, 1229, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1267, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 1265, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 1265, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR, 0, __pyx_n_s_stream_CDLEVENINGDOJISTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__356)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1265, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLEVENINGDOJISTAR, __pyx_t_6) < 0) __PYX_ERR(4, 1265, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1305, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 1303, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 1303, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_433stream_CDLEVENINGSTAR, 0, __pyx_n_s_stream_CDLEVENINGSTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__357)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1303, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLEVENINGSTAR, __pyx_t_6) < 0) __PYX_ERR(4, 1303, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE, 0, __pyx_n_s_stream_CDLGAPSIDESIDEWHITE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__358)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1341, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLGAPSIDESIDEWHITE, __pyx_t_6) < 0) __PYX_ERR(4, 1341, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI, 0, __pyx_n_s_stream_CDLGRAVESTONEDOJI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__359)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1377, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLGRAVESTONEDOJI, __pyx_t_6) < 0) __PYX_ERR(4, 1377, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_439stream_CDLHAMMER, 0, __pyx_n_s_stream_CDLHAMMER, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__360)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1413, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHAMMER, __pyx_t_6) < 0) __PYX_ERR(4, 1413, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_441stream_CDLHANGINGMAN, 0, __pyx_n_s_stream_CDLHANGINGMAN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__361)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1449, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHANGINGMAN, __pyx_t_6) < 0) __PYX_ERR(4, 1449, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_443stream_CDLHARAMI, 0, __pyx_n_s_stream_CDLHARAMI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__362)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHARAMI, __pyx_t_6) < 0) __PYX_ERR(4, 1485, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_445stream_CDLHARAMICROSS, 0, __pyx_n_s_stream_CDLHARAMICROSS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__363)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1521, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHARAMICROSS, __pyx_t_6) < 0) __PYX_ERR(4, 1521, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_447stream_CDLHIGHWAVE, 0, __pyx_n_s_stream_CDLHIGHWAVE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__364)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1557, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHIGHWAVE, __pyx_t_6) < 0) __PYX_ERR(4, 1557, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_449stream_CDLHIKKAKE, 0, __pyx_n_s_stream_CDLHIKKAKE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__365)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1593, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHIKKAKE, __pyx_t_6) < 0) __PYX_ERR(4, 1593, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD, 0, __pyx_n_s_stream_CDLHIKKAKEMOD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__366)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1629, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHIKKAKEMOD, __pyx_t_6) < 0) __PYX_ERR(4, 1629, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON, 0, __pyx_n_s_stream_CDLHOMINGPIGEON, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__367)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1665, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHOMINGPIGEON, __pyx_t_6) < 0) __PYX_ERR(4, 1665, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS, 0, __pyx_n_s_stream_CDLIDENTICAL3CROWS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__368)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1701, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLIDENTICAL3CROWS, __pyx_t_6) < 0) __PYX_ERR(4, 1701, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_457stream_CDLINNECK, 0, __pyx_n_s_stream_CDLINNECK, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__369)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1737, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLINNECK, __pyx_t_6) < 0) __PYX_ERR(4, 1737, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER, 0, __pyx_n_s_stream_CDLINVERTEDHAMMER, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__370)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1773, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLINVERTEDHAMMER, __pyx_t_6) < 0) __PYX_ERR(4, 1773, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_461stream_CDLKICKING, 0, __pyx_n_s_stream_CDLKICKING, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__371)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1809, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLKICKING, __pyx_t_6) < 0) __PYX_ERR(4, 1809, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH, 0, __pyx_n_s_stream_CDLKICKINGBYLENGTH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__372)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1845, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLKICKINGBYLENGTH, __pyx_t_6) < 0) __PYX_ERR(4, 1845, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM, 0, __pyx_n_s_stream_CDLLADDERBOTTOM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__373)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1881, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLLADDERBOTTOM, __pyx_t_6) < 0) __PYX_ERR(4, 1881, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI, 0, __pyx_n_s_stream_CDLLONGLEGGEDDOJI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__374)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1917, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLLONGLEGGEDDOJI, __pyx_t_6) < 0) __PYX_ERR(4, 1917, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_469stream_CDLLONGLINE, 0, __pyx_n_s_stream_CDLLONGLINE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__375)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1953, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLLONGLINE, __pyx_t_6) < 0) __PYX_ERR(4, 1953, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_471stream_CDLMARUBOZU, 0, __pyx_n_s_stream_CDLMARUBOZU, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__376)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 1989, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMARUBOZU, __pyx_t_6) < 0) __PYX_ERR(4, 1989, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_473stream_CDLMATCHINGLOW, 0, __pyx_n_s_stream_CDLMATCHINGLOW, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__377)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2025, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMATCHINGLOW, __pyx_t_6) < 0) __PYX_ERR(4, 2025, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2063, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 2061, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 2061, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_475stream_CDLMATHOLD, 0, __pyx_n_s_stream_CDLMATHOLD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__378)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2061, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMATHOLD, __pyx_t_6) < 0) __PYX_ERR(4, 2061, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 2099, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 2099, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR, 0, __pyx_n_s_stream_CDLMORNINGDOJISTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__379)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2099, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMORNINGDOJISTAR, __pyx_t_6) < 0) __PYX_ERR(4, 2099, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 2137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 2137, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_479stream_CDLMORNINGSTAR, 0, __pyx_n_s_stream_CDLMORNINGSTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__380)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMORNINGSTAR, __pyx_t_6) < 0) __PYX_ERR(4, 2137, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_481stream_CDLONNECK, 0, __pyx_n_s_stream_CDLONNECK, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__381)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2175, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLONNECK, __pyx_t_6) < 0) __PYX_ERR(4, 2175, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_483stream_CDLPIERCING, 0, __pyx_n_s_stream_CDLPIERCING, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__382)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2211, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLPIERCING, __pyx_t_6) < 0) __PYX_ERR(4, 2211, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN, 0, __pyx_n_s_stream_CDLRICKSHAWMAN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__383)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLRICKSHAWMAN, __pyx_t_6) < 0) __PYX_ERR(4, 2247, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS, 0, __pyx_n_s_stream_CDLRISEFALL3METHODS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__384)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2283, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLRISEFALL3METHODS, __pyx_t_6) < 0) __PYX_ERR(4, 2283, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES, 0, __pyx_n_s_stream_CDLSEPARATINGLINES, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__385)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2319, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSEPARATINGLINES, __pyx_t_6) < 0) __PYX_ERR(4, 2319, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR, 0, __pyx_n_s_stream_CDLSHOOTINGSTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__386)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2355, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSHOOTINGSTAR, __pyx_t_6) < 0) __PYX_ERR(4, 2355, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_493stream_CDLSHORTLINE, 0, __pyx_n_s_stream_CDLSHORTLINE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__387)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2391, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSHORTLINE, __pyx_t_6) < 0) __PYX_ERR(4, 2391, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_495stream_CDLSPINNINGTOP, 0, __pyx_n_s_stream_CDLSPINNINGTOP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__388)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2427, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSPINNINGTOP, __pyx_t_6) < 0) __PYX_ERR(4, 2427, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN, 0, __pyx_n_s_stream_CDLSTALLEDPATTERN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__389)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2463, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSTALLEDPATTERN, __pyx_t_6) < 0) __PYX_ERR(4, 2463, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH, 0, __pyx_n_s_stream_CDLSTICKSANDWICH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__390)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2499, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSTICKSANDWICH, __pyx_t_6) < 0) __PYX_ERR(4, 2499, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_501stream_CDLTAKURI, 0, __pyx_n_s_stream_CDLTAKURI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__391)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2535, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLTAKURI, __pyx_t_6) < 0) __PYX_ERR(4, 2535, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_503stream_CDLTASUKIGAP, 0, __pyx_n_s_stream_CDLTASUKIGAP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__392)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2571, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLTASUKIGAP, __pyx_t_6) < 0) __PYX_ERR(4, 2571, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_505stream_CDLTHRUSTING, 0, __pyx_n_s_stream_CDLTHRUSTING, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__393)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2607, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLTHRUSTING, __pyx_t_6) < 0) __PYX_ERR(4, 2607, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_507stream_CDLTRISTAR, 0, __pyx_n_s_stream_CDLTRISTAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__394)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2643, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLTRISTAR, __pyx_t_6) < 0) __PYX_ERR(4, 2643, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER, 0, __pyx_n_s_stream_CDLUNIQUE3RIVER, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__395)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLUNIQUE3RIVER, __pyx_t_6) < 0) __PYX_ERR(4, 2679, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS, 0, __pyx_n_s_stream_CDLUPSIDEGAP2CROWS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__396)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2715, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLUPSIDEGAP2CROWS, __pyx_t_6) < 0) __PYX_ERR(4, 2715, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS, 0, __pyx_n_s_stream_CDLXSIDEGAP3METHODS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__397)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2751, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLXSIDEGAP3METHODS, __pyx_t_6) < 0) __PYX_ERR(4, 2751, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_515stream_CEIL, 0, __pyx_n_s_stream_CEIL, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__398)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2787, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CEIL, __pyx_t_6) < 0) __PYX_ERR(4, 2787, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2816, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 2814, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 2814, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_517stream_CMO, 0, __pyx_n_s_stream_CMO, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__400)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2814, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CMO, __pyx_t_6) < 0) __PYX_ERR(4, 2814, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2845, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 2843, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 2843, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_519stream_CORREL, 0, __pyx_n_s_stream_CORREL, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__401)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2843, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CORREL, __pyx_t_6) < 0) __PYX_ERR(4, 2843, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_521stream_COS, 0, __pyx_n_s_stream_COS, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__402)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2876, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_COS, __pyx_t_6) < 0) __PYX_ERR(4, 2876, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_523stream_COSH, 0, __pyx_n_s_stream_COSH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__403)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2903, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_COSH, __pyx_t_6) < 0) __PYX_ERR(4, 2903, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2932, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 2930, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 2930, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_525stream_DEMA, 0, __pyx_n_s_stream_DEMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__404)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2930, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_DEMA, __pyx_t_6) < 0) __PYX_ERR(4, 2930, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_527stream_DIV, 0, __pyx_n_s_stream_DIV, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__405)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2959, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_DIV, __pyx_t_6) < 0) __PYX_ERR(4, 2959, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2992, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 2990, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 2990, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_529stream_DX, 0, __pyx_n_s_stream_DX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__406)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 2990, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_DX, __pyx_t_6) < 0) __PYX_ERR(4, 2990, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3027, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3025, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 3025, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_531stream_EMA, 0, __pyx_n_s_stream_EMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__407)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3025, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_EMA, __pyx_t_6) < 0) __PYX_ERR(4, 3025, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_533stream_EXP, 0, __pyx_n_s_stream_EXP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__408)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3054, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_EXP, __pyx_t_6) < 0) __PYX_ERR(4, 3054, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_535stream_FLOOR, 0, __pyx_n_s_stream_FLOOR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__409)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3081, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_FLOOR, __pyx_t_6) < 0) __PYX_ERR(4, 3081, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_537stream_HT_DCPERIOD, 0, __pyx_n_s_stream_HT_DCPERIOD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__410)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_DCPERIOD, __pyx_t_6) < 0) __PYX_ERR(4, 3108, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_539stream_HT_DCPHASE, 0, __pyx_n_s_stream_HT_DCPHASE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__411)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3135, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_DCPHASE, __pyx_t_6) < 0) __PYX_ERR(4, 3135, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_541stream_HT_PHASOR, 0, __pyx_n_s_stream_HT_PHASOR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__413)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3162, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_PHASOR, __pyx_t_6) < 0) __PYX_ERR(4, 3162, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_543stream_HT_SINE, 0, __pyx_n_s_stream_HT_SINE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__415)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_SINE, __pyx_t_6) < 0) __PYX_ERR(4, 3192, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_545stream_HT_TRENDLINE, 0, __pyx_n_s_stream_HT_TRENDLINE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__416)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_TRENDLINE, __pyx_t_6) < 0) __PYX_ERR(4, 3222, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_547stream_HT_TRENDMODE, 0, __pyx_n_s_stream_HT_TRENDMODE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__418)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_TRENDMODE, __pyx_t_6) < 0) __PYX_ERR(4, 3249, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3278, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 3276, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_549stream_KAMA, 0, __pyx_n_s_stream_KAMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__419)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_KAMA, __pyx_t_6) < 0) __PYX_ERR(4, 3276, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3307, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3305, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 3305, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_551stream_LINEARREG, 0, __pyx_n_s_stream_LINEARREG, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__420)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3305, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LINEARREG, __pyx_t_6) < 0) __PYX_ERR(4, 3305, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3336, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3334, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 3334, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_553stream_LINEARREG_ANGLE, 0, __pyx_n_s_stream_LINEARREG_ANGLE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__421)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3334, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LINEARREG_ANGLE, __pyx_t_6) < 0) __PYX_ERR(4, 3334, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3365, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3363, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 3363, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT, 0, __pyx_n_s_stream_LINEARREG_INTERCEPT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__422)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3363, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LINEARREG_INTERCEPT, __pyx_t_6) < 0) __PYX_ERR(4, 3363, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3394, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3392, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6)) __PYX_ERR(4, 3392, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_557stream_LINEARREG_SLOPE, 0, __pyx_n_s_stream_LINEARREG_SLOPE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__423)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3392, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LINEARREG_SLOPE, __pyx_t_6) < 0) __PYX_ERR(4, 3392, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_559stream_LN, 0, __pyx_n_s_stream_LN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__424)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3421, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LN, __pyx_t_6) < 0) __PYX_ERR(4, 3421, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_561stream_LOG10, 0, __pyx_n_s_stream_LOG10, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__425)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3448, __pyx_L1_error) + __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); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LOG10, __pyx_t_6) < 0) __PYX_ERR(4, 3448, __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3477, __pyx_L1_error) + __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_14 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3477, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - - __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 3475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_6)) __PYX_ERR(4, 3475, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_14)) __PYX_ERR(4, 3475, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_14 = 0; - __pyx_t_14 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_563stream_MA, 0, __pyx_n_s_stream_MA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__427)); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_14, __pyx_t_18); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MA, __pyx_t_14) < 0) __PYX_ERR(4, 3475, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __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_14 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3507, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 3507, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3507, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_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_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3505, __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_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_14)) __PYX_ERR(4, 3505, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_18)) __PYX_ERR(4, 3505, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_6)) __PYX_ERR(4, 3505, __pyx_L1_error); - __pyx_t_14 = 0; - __pyx_t_18 = 0; - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_565stream_MACD, 0, __pyx_n_s_stream_MACD, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__429)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3505, __pyx_L1_error) + __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_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_3); + __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_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_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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MACD, __pyx_t_6) < 0) __PYX_ERR(4, 3505, __pyx_L1_error) __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_2); __pyx_t_2 = 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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 3544, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3544, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 3544, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_14 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3544, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3544, __pyx_L1_error) + __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_7 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3544, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3542, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6)) __PYX_ERR(4, 3542, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(4, 3542, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_18)) __PYX_ERR(4, 3542, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_14)) __PYX_ERR(4, 3542, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_t_2)) __PYX_ERR(4, 3542, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_t_7)) __PYX_ERR(4, 3542, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_3 = 0; - __pyx_t_18 = 0; - __pyx_t_14 = 0; - __pyx_t_2 = 0; - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_567stream_MACDEXT, 0, __pyx_n_s_stream_MACDEXT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__431)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3542, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MACDEXT, __pyx_t_7) < 0) __PYX_ERR(4, 3542, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __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); + #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; - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3584, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __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_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3582, __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_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7)) __PYX_ERR(4, 3582, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_569stream_MACDFIX, 0, __pyx_n_s_stream_MACDFIX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__433)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_4); + __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_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_d, __pyx_n_s_stream_MACDFIX, __pyx_t_7) < 0) __PYX_ERR(4, 3582, __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_stream_MAMA, __pyx_t_15) < (0)) __PYX_ERR(5, 3719, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3619, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3619, __pyx_L1_error) + __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_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_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3617, __pyx_L1_error) + __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_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); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_7)) __PYX_ERR(4, 3617, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(4, 3617, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_571stream_MAMA, 0, __pyx_n_s_stream_MAMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__435)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MAMA, __pyx_t_4) < 0) __PYX_ERR(4, 3617, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3652, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3652, __pyx_L1_error) + __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_7 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3652, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_14 = PyTuple_New(3); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3650, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_4)) __PYX_ERR(4, 3650, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_2)) __PYX_ERR(4, 3650, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 2, __pyx_t_7)) __PYX_ERR(4, 3650, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_2 = 0; - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_573stream_MAVP, 0, __pyx_n_s_stream_MAVP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__437)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3650, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MAVP, __pyx_t_7) < 0) __PYX_ERR(4, 3650, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3687, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3685, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3685, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_575stream_MAX, 0, __pyx_n_s_stream_MAX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__438)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3685, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MAX, __pyx_t_7) < 0) __PYX_ERR(4, 3685, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3716, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3714, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3714, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_577stream_MAXINDEX, 0, __pyx_n_s_stream_MAXINDEX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__440)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3714, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MAXINDEX, __pyx_t_7) < 0) __PYX_ERR(4, 3714, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_579stream_MEDPRICE, 0, __pyx_n_s_stream_MEDPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__442)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MEDPRICE, __pyx_t_7) < 0) __PYX_ERR(4, 3743, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3775, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3773, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3773, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_581stream_MFI, 0, __pyx_n_s_stream_MFI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__444)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3773, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MFI, __pyx_t_7) < 0) __PYX_ERR(4, 3773, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3813, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3811, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3811, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_583stream_MIDPOINT, 0, __pyx_n_s_stream_MIDPOINT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__445)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3811, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MIDPOINT, __pyx_t_7) < 0) __PYX_ERR(4, 3811, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3842, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3840, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3840, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_585stream_MIDPRICE, 0, __pyx_n_s_stream_MIDPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__446)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3840, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MIDPRICE, __pyx_t_7) < 0) __PYX_ERR(4, 3840, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3874, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3872, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3872, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_587stream_MIN, 0, __pyx_n_s_stream_MIN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__447)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3872, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MIN, __pyx_t_7) < 0) __PYX_ERR(4, 3872, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3903, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3901, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3901, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_589stream_MININDEX, 0, __pyx_n_s_stream_MININDEX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__448)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3901, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MININDEX, __pyx_t_7) < 0) __PYX_ERR(4, 3901, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3932, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3930, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3930, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_591stream_MINMAX, 0, __pyx_n_s_stream_MINMAX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__450)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3930, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MINMAX, __pyx_t_7) < 0) __PYX_ERR(4, 3930, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3964, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3962, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3962, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_593stream_MINMAXINDEX, 0, __pyx_n_s_stream_MINMAXINDEX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__452)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3962, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MINMAXINDEX, __pyx_t_7) < 0) __PYX_ERR(4, 3962, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3996, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 3994, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 3994, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_595stream_MINUS_DI, 0, __pyx_n_s_stream_MINUS_DI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__453)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 3994, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MINUS_DI, __pyx_t_7) < 0) __PYX_ERR(4, 3994, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4031, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 4029, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 4029, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_597stream_MINUS_DM, 0, __pyx_n_s_stream_MINUS_DM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__454)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4029, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MINUS_DM, __pyx_t_7) < 0) __PYX_ERR(4, 4029, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4063, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 4061, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 4061, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_599stream_MOM, 0, __pyx_n_s_stream_MOM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__455)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4061, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MOM, __pyx_t_7) < 0) __PYX_ERR(4, 4061, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_601stream_MULT, 0, __pyx_n_s_stream_MULT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__456)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4090, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MULT, __pyx_t_7) < 0) __PYX_ERR(4, 4090, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4123, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 4121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 4121, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_603stream_NATR, 0, __pyx_n_s_stream_NATR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__457)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_NATR, __pyx_t_7) < 0) __PYX_ERR(4, 4121, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_605stream_OBV, 0, __pyx_n_s_stream_OBV, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__459)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_OBV, __pyx_t_7) < 0) __PYX_ERR(4, 4156, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4189, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 4187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 4187, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_607stream_PLUS_DI, 0, __pyx_n_s_stream_PLUS_DI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__460)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_PLUS_DI, __pyx_t_7) < 0) __PYX_ERR(4, 4187, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 4222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7)) __PYX_ERR(4, 4222, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_609stream_PLUS_DM, 0, __pyx_n_s_stream_PLUS_DM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__461)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_PLUS_DM, __pyx_t_7) < 0) __PYX_ERR(4, 4222, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4256, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_14 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 4256, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_2 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4256, __pyx_L1_error) + __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_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_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4254, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7)) __PYX_ERR(4, 4254, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_14)) __PYX_ERR(4, 4254, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2)) __PYX_ERR(4, 4254, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_14 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_611stream_PPO, 0, __pyx_n_s_stream_PPO, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__462)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4254, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_PPO, __pyx_t_2) < 0) __PYX_ERR(4, 4254, __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_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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4287, __pyx_L1_error) + __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_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4285, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(4, 4285, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_613stream_ROC, 0, __pyx_n_s_stream_ROC, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__463)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4285, __pyx_L1_error) + __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_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ROC, __pyx_t_2) < 0) __PYX_ERR(4, 4285, __pyx_L1_error) + + __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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4316, __pyx_L1_error) + __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_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4314, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(4, 4314, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_615stream_ROCP, 0, __pyx_n_s_stream_ROCP, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__464)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4314, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ROCP, __pyx_t_2) < 0) __PYX_ERR(4, 4314, __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_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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4345, __pyx_L1_error) + __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_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4343, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(4, 4343, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_617stream_ROCR, 0, __pyx_n_s_stream_ROCR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__465)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4343, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ROCR, __pyx_t_2) < 0) __PYX_ERR(4, 4343, __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_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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4374, __pyx_L1_error) + __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_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4372, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(4, 4372, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_619stream_ROCR100, 0, __pyx_n_s_stream_ROCR100, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__466)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4372, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ROCR100, __pyx_t_2) < 0) __PYX_ERR(4, 4372, __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_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_2 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4403, __pyx_L1_error) + __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_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(4, 4401, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_621stream_RSI, 0, __pyx_n_s_stream_RSI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__467)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4401, __pyx_L1_error) + __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); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_RSI, __pyx_t_2) < 0) __PYX_ERR(4, 4401, __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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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 = PyFloat_FromDouble(((double)0.02)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4432, __pyx_L1_error) + __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_4 = PyFloat_FromDouble(((double)0.2)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4432, __pyx_L1_error) + __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_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 4430, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_2)) __PYX_ERR(4, 4430, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_4)) __PYX_ERR(4, 4430, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_623stream_SAR, 0, __pyx_n_s_stream_SAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__469)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4430, __pyx_L1_error) + __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_14); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SAR, __pyx_t_4) < 0) __PYX_ERR(4, 4430, __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 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4465, __pyx_L1_error) + __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_14 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 4465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_18 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_19 = PyTuple_New(8); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4463, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_4)) __PYX_ERR(4, 4463, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_14); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 1, __pyx_t_14)) __PYX_ERR(4, 4463, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 2, __pyx_t_2)) __PYX_ERR(4, 4463, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 3, __pyx_t_7)) __PYX_ERR(4, 4463, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 4, __pyx_t_18)) __PYX_ERR(4, 4463, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 5, __pyx_t_3)) __PYX_ERR(4, 4463, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 6, __pyx_t_6)) __PYX_ERR(4, 4463, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 7, __pyx_t_15)) __PYX_ERR(4, 4463, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_14 = 0; - __pyx_t_2 = 0; - __pyx_t_7 = 0; - __pyx_t_18 = 0; - __pyx_t_3 = 0; - __pyx_t_6 = 0; - __pyx_t_15 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_625stream_SAREXT, 0, __pyx_n_s_stream_SAREXT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__471)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4463, __pyx_L1_error) + __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_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_19); - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SAREXT, __pyx_t_15) < 0) __PYX_ERR(4, 4463, __pyx_L1_error) + __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); + #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_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_627stream_SIN, 0, __pyx_n_s_stream_SIN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__472)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4502, __pyx_L1_error) + __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); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SIN, __pyx_t_15) < 0) __PYX_ERR(4, 4502, __pyx_L1_error) + __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); + #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_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_629stream_SINH, 0, __pyx_n_s_stream_SINH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__473)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4529, __pyx_L1_error) + __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_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SINH, __pyx_t_15) < 0) __PYX_ERR(4, 4529, __pyx_L1_error) + __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); + #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_15 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4558, __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, 4476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); - __pyx_t_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4556, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_15)) __PYX_ERR(4, 4556, __pyx_L1_error); - __pyx_t_15 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_631stream_SMA, 0, __pyx_n_s_stream_SMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__474)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4556, __pyx_L1_error) + __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_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_19); - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SMA, __pyx_t_15) < 0) __PYX_ERR(4, 4556, __pyx_L1_error) + __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); + #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_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_633stream_SQRT, 0, __pyx_n_s_stream_SQRT, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__475)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4585, __pyx_L1_error) + __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); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SQRT, __pyx_t_15) < 0) __PYX_ERR(4, 4585, __pyx_L1_error) + __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); + #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_15 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4614, __pyx_L1_error) + __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_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_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4614, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_15)) __PYX_ERR(4, 4612, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_19); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_19)) __PYX_ERR(4, 4612, __pyx_L1_error); - __pyx_t_15 = 0; - __pyx_t_19 = 0; - __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_635stream_STDDEV, 0, __pyx_n_s_stream_STDDEV, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__477)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_STDDEV, __pyx_t_19) < 0) __PYX_ERR(4, 4612, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_19 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4644, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __pyx_t_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4644, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_15 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4644, __pyx_L1_error) + __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_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); - __pyx_t_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4644, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_18 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4644, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - - __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4642, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_19); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_19)) __PYX_ERR(4, 4642, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6)) __PYX_ERR(4, 4642, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_15)) __PYX_ERR(4, 4642, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_3)) __PYX_ERR(4, 4642, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_t_18)) __PYX_ERR(4, 4642, __pyx_L1_error); - __pyx_t_19 = 0; - __pyx_t_6 = 0; - __pyx_t_15 = 0; - __pyx_t_3 = 0; - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_637stream_STOCH, 0, __pyx_n_s_stream_STOCH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__479)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4642, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_STOCH, __pyx_t_18) < 0) __PYX_ERR(4, 4642, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4686, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4686, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4686, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + #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 = PyTuple_New(3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4684, __pyx_L1_error) + __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_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_18)) __PYX_ERR(4, 4684, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_7)) __PYX_ERR(4, 4684, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 2, __pyx_t_3)) __PYX_ERR(4, 4684, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_7 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_639stream_STOCHF, 0, __pyx_n_s_stream_STOCHF, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__481)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4684, __pyx_L1_error) + __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_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); + __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_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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_STOCHF, __pyx_t_3) < 0) __PYX_ERR(4, 4684, __pyx_L1_error) + __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_3); __pyx_t_3 = 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); + #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 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 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_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); + #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 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_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4716, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + + __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_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_3 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4726, __pyx_L1_error) + __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_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_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_15 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4726, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4726, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_18 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4726, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4724, __pyx_L1_error) + __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_16); __pyx_t_16 = 0; + __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_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); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(4, 4724, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_15)) __PYX_ERR(4, 4724, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_7)) __PYX_ERR(4, 4724, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_18)) __PYX_ERR(4, 4724, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_15 = 0; - __pyx_t_7 = 0; - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_641stream_STOCHRSI, 0, __pyx_n_s_stream_STOCHRSI, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__483)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4724, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_STOCHRSI, __pyx_t_18) < 0) __PYX_ERR(4, 4724, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_643stream_SUB, 0, __pyx_n_s_stream_SUB, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__484)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4759, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SUB, __pyx_t_18) < 0) __PYX_ERR(4, 4759, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4792, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - - __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4790, __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_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_18)) __PYX_ERR(4, 4790, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_645stream_SUM, 0, __pyx_n_s_stream_SUM, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__485)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4790, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __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_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_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SUM, __pyx_t_18) < 0) __PYX_ERR(4, 4790, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __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_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_3) < (0)) __PYX_ERR(5, 4786, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 4821, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4821, __pyx_L1_error) + __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_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_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4819, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_18)) __PYX_ERR(4, 4819, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6)) __PYX_ERR(4, 4819, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_647stream_T3, 0, __pyx_n_s_stream_T3, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__487)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4819, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_T3, __pyx_t_6) < 0) __PYX_ERR(4, 4819, __pyx_L1_error) + __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_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_649stream_TAN, 0, __pyx_n_s_stream_TAN, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__488)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4849, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TAN, __pyx_t_6) < 0) __PYX_ERR(4, 4849, __pyx_L1_error) + #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_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_651stream_TANH, 0, __pyx_n_s_stream_TANH, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__489)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4876, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TANH, __pyx_t_6) < 0) __PYX_ERR(4, 4876, __pyx_L1_error) + #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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4905, __pyx_L1_error) + __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_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4903, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6)) __PYX_ERR(4, 4903, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_653stream_TEMA, 0, __pyx_n_s_stream_TEMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__490)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4903, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TEMA, __pyx_t_6) < 0) __PYX_ERR(4, 4903, __pyx_L1_error) + __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_655stream_TRANGE, 0, __pyx_n_s_stream_TRANGE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__492)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4932, __pyx_L1_error) + __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 (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TRANGE, __pyx_t_6) < 0) __PYX_ERR(4, 4932, __pyx_L1_error) + #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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4967, __pyx_L1_error) + __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_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4965, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6)) __PYX_ERR(4, 4965, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_657stream_TRIMA, 0, __pyx_n_s_stream_TRIMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__493)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4965, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TRIMA, __pyx_t_6) < 0) __PYX_ERR(4, 4965, __pyx_L1_error) + __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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4996, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4994, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6)) __PYX_ERR(4, 4994, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_659stream_TRIX, 0, __pyx_n_s_stream_TRIX, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__494)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4994, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TRIX, __pyx_t_6) < 0) __PYX_ERR(4, 4994, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5025, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5023, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6)) __PYX_ERR(4, 5023, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_661stream_TSF, 0, __pyx_n_s_stream_TSF, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__495)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5023, __pyx_L1_error) + __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_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_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_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_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_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_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_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_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_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_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TSF, __pyx_t_6) < 0) __PYX_ERR(4, 5023, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_663stream_TYPPRICE, 0, __pyx_n_s_stream_TYPPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__496)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5052, __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_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 (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TYPPRICE, __pyx_t_6) < 0) __PYX_ERR(4, 5052, __pyx_L1_error) + #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_6) < (0)) __PYX_ERR(5, 5187, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5087, __pyx_L1_error) + __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_7 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5087, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 5087, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); + __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_15 = PyTuple_New(3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 5085, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_6)) __PYX_ERR(4, 5085, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_7)) __PYX_ERR(4, 5085, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 2, __pyx_t_18)) __PYX_ERR(4, 5085, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_665stream_ULTOSC, 0, __pyx_n_s_stream_ULTOSC, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__498)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 5085, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_18, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ULTOSC, __pyx_t_18) < 0) __PYX_ERR(4, 5085, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 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); + #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_18 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 5124, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 5124, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __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 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_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_18); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_18)) __PYX_ERR(4, 5122, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_15)) __PYX_ERR(4, 5122, __pyx_L1_error); - __pyx_t_18 = 0; - __pyx_t_15 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_667stream_VAR, 0, __pyx_n_s_stream_VAR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__499)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 5122, __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_d, __pyx_n_s_stream_VAR, __pyx_t_15) < 0) __PYX_ERR(4, 5122, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 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_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_669stream_WCLPRICE, 0, __pyx_n_s_stream_WCLPRICE, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__500)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 5152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_WCLPRICE, __pyx_t_15) < 0) __PYX_ERR(4, 5152, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __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); + #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_15 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 5187, __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, 5324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); - __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5185, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_15)) __PYX_ERR(4, 5185, __pyx_L1_error); - __pyx_t_15 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_671stream_WILLR, 0, __pyx_n_s_stream_WILLR, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__501)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 5185, __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_d, __pyx_n_s_stream_WILLR, __pyx_t_15) < 0) __PYX_ERR(4, 5185, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __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); + #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_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_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_6); __pyx_t_6 = 0; + for (;;) { + if (likely(!__pyx_t_33)) { + if (likely(PyList_CheckExact(__pyx_t_19))) { + { + 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_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_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_6 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_19, __pyx_t_18)); + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_19, __pyx_t_18); + #endif + ++__pyx_t_18; + } + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 8, __pyx_L1_error) + } else { + __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) + PyErr_Clear(); + } + break; + } + } + __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_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_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_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 ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __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_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_19); + __Pyx_XDECREF(__pyx_t_20); + __Pyx_XDECREF(__pyx_t_21); + if (__pyx_m) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init talib._ta_lib"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #else + return __pyx_m; + #endif +} +/* #### Code section: pystring_table ### */ +/* #### 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_enumerate = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 82, __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_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; +} +/* #### Code section: cached_constants ### */ + +static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_n_u_real, __pyx_mstate_global->__pyx_n_u_price); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(2, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); + + __pyx_mstate_global->__pyx_tuple[1] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(1, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]); + __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(1, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]); + + __pyx_mstate_global->__pyx_tuple[3] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(1, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]); + __pyx_mstate_global->__pyx_tuple[4] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(1, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]); + + __pyx_mstate_global->__pyx_tuple[5] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[5])) __PYX_ERR(1, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[5]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[5]); + __pyx_mstate_global->__pyx_tuple[6] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[6])) __PYX_ERR(1, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[6]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]); + + __pyx_mstate_global->__pyx_tuple[7] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[7])) __PYX_ERR(2, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[7]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[7]); + __pyx_mstate_global->__pyx_tuple[8] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[8])) __PYX_ERR(2, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[8]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[8]); + + __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 CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #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_IMMORTAL_REFCNT_LOCAL); + } + #else + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + { + 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},{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 (12652 bytes) */ +const char* const cstring = "BZh91AY&SY\365\014\231o\000\035>\177\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\300@@@@@@@@@@@@\000@\000`9\335\335\363\276\357np\000>>{8A\321\336\367y\234\243\354\001\364\017\235\217\235H\327\311\203\344\356\366\372\316\303\337ww\337{\357\r}\222v\347\006K-+=\332w\333\357z\353_u\215;\316\000\014\032\017\274k\304\325o\2716\355\263v\364\017\\\257u\337{\036\273\274{\314\2265\230:r\333\351\353\333\333\321\242y\221g\200;\354\r\3631\327X\275\367n\366\340\n(\004\000\000+\260\342\3132B\007\330\016^\004\222\020D\023\021\246\023&\r\006&\206\225=\350\324\314\321\0312\000&\246\201\2655&\3152\246\217b&S\364Bh\003OP~\250$\210\001\001\023Djf\200M\031\006\246\232\233$\361\275UO\310\321\032\236 @\3650=S\322cCF\243\006\201\2416\236\251\355Q\352\006\230B\224\311S\312\0324`\2004\3100\020\323\010\001\352\000\310\001\246\203C@\003\004\000\r\036\240\002M(\202 M\006\204\332\010\231=OF\223\024\374\232ML\2312\r\003M4\0004h\000\r\001\240h\000\003A\024B\022$\215\032z'\244\364\323\324\362\032\241\275MO\322l\247\250\237\252z'\222=L\017\014M5B\032z\214a\020\321\351=M\243MOH=4j\002%\"\020\030h\021\2651\032hh\231\006E\036SM2&\006\203Sj\r\r\000\006\200\003@\001\243OH\017\271\000\204\201\267'\224\363!\350|\376\375\216q\360\344\t\201\034S\337\326\230s\243y\357\020\360\"\242@\316+%\002k\301\350\t]X\024\013X\301\005\252\t\200yV\225\214\206\263F\200\341\324,\035\274\301\330d\370\351Pe(\310^\357\260\005\200\016h\201\"\203 $ \264\200\322\002\224\212\205\"\203\"$\200\022\000\251F\"\254\200\243$\200\260\223\354[\000\" \022\240\005\031$\026\021D\"\005B\220(5{\007l\216\317\367O\227\374\021\333\265\276n\345\345\335\323\350&\237\317\272B*r\301\376D\3623(\327,\3034U\037\374\357!\251V\"\022x[&\275-\000x+\23719ft\006,\3351\305\300Mr\262z8\261c=\036\271\242\177\270\004N\360\277R\325\357\237X\237b]qK\276\274-\005\226\2608\0210D\312E\256a\262\004\014\244&,1\203FfB2\020d\r\306\030B\032\271\004\327\032WI\234+\271t\3278\334\r\204\200L\244@\\\323\207WQ\3719M~\310.\252\025\257\355!|\362\227_(~\342""\260\301\332\323\367K\260\277x\016\2750\307\314\213\260\017\267w\217\375\221\202\216\227\317\336\372?\356\270\024u\332\360\377\002\342\2469\206\031\215x\177\010\272\014M\2402b6\355\177\020\271\030\261\007\030;_\201teL\265i#\037\306p\211\224\026\237\310p5\311\253\224\216\337\362\204\370\231jg\201\266(\253\370QE\036:S5\245\003\371\205\306cL\256Dd\320g_\316\007\035q\205\261#\361\013\027\226-\241\"k\377\013\206-lm\264\250u\177\345T\231C'\204O\350E\302ms\204vh\263\037\322(\027'\275\t8\322o\352\013G\267\321\267\031\243\372\314\2437\355r\241\273\323\373\026\321\3508\305\037\215KX\310\343\300\234\241\375\253YC\201\301\2110\303\177r\201\252\206\306\322?\275\017\233\021:\r\330\221\325\376\002\216l\315.\216\003H9\2138\307\257z\362\241\376(\211\003\217\002=\014~HGq\240\217\014!\035O\362\321\361\311g\351\246n\320\032\023?\316\014\314\314q\362\177\246\345q\000\325\365\351\364q*\3737\005v\333\377GL{\177\353\313\255\214V+\362\256Zuo\025\376\307\"\246\320\031\217\235p\351\322x\221\377\265\311\215\371k\266\032_Q\034\270\233\351\010\374!\306\334\240?\346Y\333x}\032\307\247F\213\343\337.Kh\357\221>}\246M]\306\255\3535\351Y\260\307S\036\224N\271\3632\350\347l\370s\037\234\333I\356\3737L[\230S\236\032<\271\360\343\265>\251\233V\273\350sS\347\256\324\231\325\023g_8RE\341^\000\274\202\360_K\215bV\253\275z\363\351\276\036\r\336-^\031|\004\351_\247v,+\225u%\313\271B\326\345\273Z:\2706\356qO\311\273\217\217k\006\265\254Ku\2633Iv\"\342\320\226\356\325\233\327s.O\325\274^\275O\037\033\212<\272y4\262\250`\345\361e\241,\224\221\260%\262\220d\211\031\000.\362\246\305\r\252\033\0048U\354\007\271{\021\353\020\322\241\322\211\336\001\350G\320\247\202=\312\032\3047\003\326/Z\026\203\324\001\264\036H\206\242\006\232:jyBt\227\244'I^\212\276X\364T\351\t\256\202\240\213\3026\004l\010\330\003m\025R\340\005Y%\270#\310+\241p/*\351^A\276\257\n\310\257\nd\026lX\261\265\266\375\357/\227\313\036\315V)a_\002\322<\035[\207\036s\341F\237\263\314\253W\231n'{\237Kt\345\244t\351\032\331\306=0c\315)SV\347\225\365\233""\363\306m\267=s\277\250\360\306\374\316\021\310\177O\r\337\323\031c>\310C\342\347-\345\247x\215j\376\235\261\027\3477\327\3227\213L\366\247\2447~\032\361\364\256\005_\322qQ\336\022\365C\234\366\247\2148\353\314\336\274\315&s4\2373B\274\326D\272\271\23664\217\254\264\347\245\271\346[\177\212{\374\\/\317\206\025\215\231\366'X&\357\331\300\032m\303\002bi\361\311g\303}\005\364\204_/\350\356d\326\243\345\362\315\213_7g*K~X\264\251X\256\367\276\216\2058R\245KV\226\216~\247\177O2\234\300\261Dd \262)\221\264\215\321i\006\220h\206z\230Y\311x\302\302[\302\231\023\"dWS)\202\2111eL-\224m)\2210\033)l\243d\r\2006\026\302\330\r\205P5\305M\024\212U\302\311\274\266\354X&+Ln-\300\334+\371f\264[\336\255\334\221\361\017\212f\022BQ\210\202\020\212\242\310\242\244\200\002\222\004 Fa\200@\230\370\307fi\033z\325\235\375\375\373q\357\357\317\232j\363O\255Z\315\235\335\275\275\335\374}\275\357%\372\271^M\275\275\2716\365\370\220\027Qu\034\310\346G0\034\334\230YW\363\355a\323\327*k\346\024J:\345*\224\217\031\207R\245*U5\265jT\312\247R\246\251R\235J\2325*h\324\330\265\027H\204#S\342\252\2052\250s^k\347o\006\033H\336\336\336^;\010l\030&\210h\205\355\345\034C\265\2640X,Y\024R\n\004Y\005\204U\213$\214\310\375\372\241eT!\025\014\214\222\310\324H\262@\331f\200\025\202\302\235,\240n\230`~\275\337\352\315wE\336\243\320\2503\342\261\r\001\355&u\016ige \021\341\315\230\344\370\026\333\250 }\371\010\305 \221\200-\333\2724)\314\032/7\203@\350^$\r0\026FAN4\245\017\301|\005\r\3417\204\2202Yw\\.\024\354C\027C\025\002\312\310@Pd\010\003m\215\266'2cC\032\254!\nI!Hd\306\367Z\326HB\230N\033H~\231\222Z\2101F\"\264\t#\254\326\342L\364\364\001\024\021\t\270Z^\216\020\324\327\367\354\263x\301X\226I!]\307MB\2113\010\ro\216\rt\213\227\262\021\013\241\304@a\"\210\005`@m$c\000\212Nc\244&\3048\220\3438\303\265\003\262m\303\201\024RN(M\316\002\303f\212\212:\361\230\016!\300AT\212@\306\030\2048\230\213\254\321\325\305m,T\021\252\030\006&\022\271Q\252\273%$\250\255\315B\367\362\r\352\n\032\0336A\374\233\01066\213\214,\010""\005ah\006H\327D\032\231\252\201m\022\313X\264FL\226\254\014\320\331g]cM\304pd`M\020\262i\014\343\262e\272\020+#t\033\210\335\033\202\334\260`\006\004\204_\360\341<\007\r\030\331,\326b\0038\237\212\351$\267*\002\264\254\t\005\200\260\204X\324F\251\032\233d\222\306\001\261\233\276\256\346`,\262\275BH\225\302\351^D\254A\246\220Y%d\262HFH0X\376\214[ld6B\022\311\006F0\006\345\312\227\263XAD\204BBH?\247\023w\232\003u\221\220\032\337 \331ab\353\030\004[DlX+\254\030\230\2643\230L:\003a\262+\003\245Y!n\341O\276\204/\304\022\003)\375\360\020\344r\001\352@\237\027&\246\256\255\372\246\256h\275\213\212\314\321\310R\272\030Sn\372\021\203\363\376\177\317O\245\355\177\326\341\374\320\317\3647=\"1\233<8kL0\353\341\221\247\340\215\212\304\367\236vf\202\214T\t\2509\014R\205\376\257\3032\014\025\326\364\367\261<\2324\206K\201B;_\337\207U\231e\243\301\241\370\\\035\227q\311\311i\363E\367E\332\277\350Pq\264}\257\010F\254\366\327\362\306\215\261\3266\371\326\315\010=\273\317\367\245\027y\351H?Y:O\020\177\212r\214k\255\024 J\031m\215K\303&\350\215\247\373\327\301\311\214c\226\235\223\241L4\264\211ll\324\242\332\033Z$\371\273\220\016\313\325\244n\367\204\232\017\264s\312d'{E\362kBX\n\341A\337\t\317{\236\351\314}qC\026J\"\251\261\270\342\251\3756\226\307\220\030\335\332\252\017HI\023\313\000K\022#\024\225\321\272\247\023\242\267\"Nf`\212\016\002\304\006\224$\006\034.:\2762\336XQe\210@\2100F\233zJv\306\001\\\253\250T\222\004PE\025\212+\036S\231\256I\006_\217\361\207G\244\324\"9\034\313sb\310\262J\205Csqn\205d\226\342\335\006\346<\337\003\235\347\366>\326\333 \027\366\213\257\247p\207\000\340p8\177\257\330B\003l\002\352\257\367\212\356\035XXX\00389\317\370\356\3439\241\r>Y\220\023\026\034D\034!\365~\243\211\304a\376\314\252\032\257\356&&\"S\263\302e\256WN\351\217\036\024\261l\016\332\271\265\325\220r%\241\225\264\256o\367\261k0\361\264\373\355\220n7\253\345\356\336\373\017\302&=.p\377\240u\330G\237\305[A-\0038\3155t\rF\265\326iC\310\344:\304y=oyC\253\204\371\233C\264\271v\023\030\0021\266gN""\017\363\005\210#X\300\377,P\3768\250\027\306\216jl\346\366\323\331\271\014\213\231&K\025\r\035\014\200\310\002\277\207Rh\234\311\312\231M\323dSt\354Os\204\335\232h`\326$\236\334\370\"\025[\224S\017l\306R\005\007\200\356\347\025\252\335=\306Srp\304\01034\026\350Yq9\261y\222L\31135tt\t\217\266G\207\263Z\225\331\342\3639\215K\243[[X>\003\304\330\211\322m\031\t\t\010\033j\371\370Lv\362\350k-.5b\233\032\307`\362Me<&Rm\336\301\211\277\030\330i\353\345W\023\220\017$e4\353\312\302\205U\203\014\022\022\025XB\0310\t\016\351\221\037\035/\014\014\300\220d\215\267\225\305:\347D\222NT\034\201\004\020E\344d\362\225i\253\260`3x\347D\320\031U\336\260b\374\376|\207=gN\305\305\305f\305\361\225\205X\254*\300{>\337\223x\372>\263\202\305M\257R2\004\n$O\364\303\344P\352|\235\347P0\034_65u)`>\232\313\252\313/\021\331\177#\211h\350\203K\025\321ko\265>b\322\3647\257\201\335\352h\246(\330Z\212\213\032,\263WR\302eM\006\202\365\224\325\024\003\n*S\030(\3163N\361TS!4\311\3458j^\2725\236\3230\304\263\275L\330\276\005\010Nb`\035\221\340\320p\325\231\231\224\344\324=\217\026\030%=[g\333Sf%\255\252d\305\374lw\005\342\017\007gx1\335\001wQ\3303&2B2Q<\364\016\360\317\211\227\231\312\372\241\221\205\247\211\234\250<\375\246^\306?}v\217\216\326\361+\215I\3729~\334\332#\363\335\314@>o\235\325\031F\363\003\261/A\343\236\361=\036A\350\222\036(y\021U\212\301\nO!\201iN\374\347\0377C\rk\330\301\353jh\227\032=\305HU\025\330\306\353y\307R\025\260.D6Q\014\267\006\036T5\335\013\236\321\335\313\313\344h\375\037\2078'#\312#\026\")C\27704\370\357s\334U\354\330\037,\237*{\347\275Y\230\014\373\302d\rD34&\223\023\252\264\270\305}""\255N\t\335O\226\225$:\036o\327\325\321w\367\256\037\262`/\340\301I\251\325\251MF\2457?C\264\375<\206\245\ra\316\302\020J\006\266\2059\354u\004l\366\276\311\251\003\241\371\243u\251\270\362\001\203\002H\312j:m\233\332;.\221VGKE\202\217\255\207'J<(=/)\024^rL\260\026/<\335\354\364\354Fs\316\364\336vf\206\210\243\275k\010\250\3061\232\232\302d\256\270(\007\310\244\2114\003\320\240'D\324`\333\252\233\346\243\025\3113&d\324\206QUi>\225&l+(M1!\306k*m{\036\332Pi\353\344\237\206\241\262\307\206q\322\376\002\303\210\356;\273\236\343\2657?\001\324\241\326\273\241\"\024\r\305\032\024\335\357\364\"v\236&\007\001\363\r\360\016\0048H\205\036\022\222\234=\203\217Y\354m\r\014xj\t$\351\037\240\3265\216.\252\204\272\350\240c\024K\016T='&\274h\345\014\320J\016d\2453i\033\354\034l\007CF\216\246\226\227\032\306\250\345\217\204\033\213\020A\314\363\207\322\230\225#\337\224\222o<\026R\\\246\351\3563\027Jy\342c\026\3313\254\244c\022$\344\224,\223l\234\323\223\301\202\223I\31756\217\023[F\r\306\000\316\036\000\251\276\021\214\037\001\216\373\307x\367\365\036\251\364\217\\\363\376\013\327\357\364\235\323\264vn\326\274\350E\350JB\207A\217-\246\250U\016b\365z3\207\257\322\252\366\225|[\232\352\343\035\275&\314\3064\324\337\307U\360\265f\303\306\325)\026\274-/\024\327\262/j\27611Y\016\025sf*\263s&\031\2123\2616Tq\231\205\275\270g\201\315:\372$+C\243\324KWSI\274\360\302\t\250z\361\016\014\336\254\325\343\325\336VS]\317\n\311\005\002\225w\320QX^{A;\263Fy\346,\323\351e\"\021\321\233K\014\354\360XWN\026\273YaTT^r\212\270[\0364\304\024rF\t\304\242\237\342\257D,\303\274\323g\255\002\335\267J""\264\rs\373\277=\004\203H\025&\002Pv\214\333\321\3306\215\036\207\234\257\310\247.\246\242\257<\251\336t\275n\300\251\365[\263\031(\035\3300\315\347\205\0335\337\275Fb\230f\234bF9Y]T\314}3\236\027\244\353\222o#\277|\3461\204\037\235I5_/\337\277\177|\316\211\240SD\242hI\243\225\304\032\030\201\247\335\022\022\036\237\233U@\200\373V\202V\374\346za\3515\222I\234\366\374~\326\234\000\207\003f)\024R\204\021\312P\001\325\023CG(_#x\026\264B\024\001\014;\216\027\t[Wk*\215e\312\360\000bR\302-\022\304\263\277\223\236\231\335\216\214\236r!\260\264\211py-1\024\n\260@B\371\215\025\250\325\3215\322t\364R((\271\256E\330\376,8TQ\222\315\201P\210\227\t\214ag\307\360n\256r>\271\331\346\306b \360\307\014\235\214\351\031\376\206T\234\025\236n\"sp\377\201\343\177/?>\272\353|\223\014\r\202\032\304\317\276\220x\221\341\023\322m\003k\227b= \033aD\332\223n-\266{\235y\217z\027n\335\371\305\3375+\223\274\220v.\256\245d\347md\247!1\355\307\306\273\211\224!\222w\255\225\024\\\216\223L-&,\366\023i\244\326q\2301\223y\231\312{*>X\225GDva\265\233lg\273\303\016\362\242\322\306\027\225k\003\327c\331c\002\323\325M\003u\346u\000\332L\n\030\322`\002{\342\201\020\033\262\"\211\254\334<\357f\315\231\243\362\316\311\311l\243\275\242\225`\245._\365\311\342x\036\035\373\016#\356\366)\332\214{JS\267\321\2431\3652u\272\316\267\032\311O\243)E\356f\202\005\032\227Y\371cR\303\353\307\301\314\203\207\321\210\237.\026M\027\220XN\325\3665\177_x\3271\275\207/\007mo\022\360\205)Ly\255lx\361B\326\306\010\327H\345\210Re\014\370\273\323n\035\017nGE~W\362\037\021\3611\030tq\331\227\n\245i\276\\'\334n\213\302[{\316\373\2652\235bE\243\333%\2158\272\326s\351\337\324\256|6\254{\333i\325\301\337\321\275}\033[\331\347\372\177c\353_\333\307\203D\321\206\255\031\362U%\327C\216\260\327\\\342\\\315\304\351\325\276=\033\322I\032\342\315%Ep\232\354Ndws[S\023A\232e\205\005\221\246L\314)&\321\244\232,\310k4\323\306\362X\216$\362\222\315z\004Y\033\263\250\027\340&\034\243C\021eI\315\240x\376\312\255\236_n>\301\323""\321\323\323y\365:\017\205\337\347\220\003\234\034\340y\301\266\210\233\nm\256\333oH\361{\\\366N*;B\303\347\276 \325\334<\206\366\216\233\314\342\352F\245\013:\201\201\307n\226\264ge\342<\212\304DA\004\234e\3005\244'8\207\206\257~\351\254A5\246\215f\264\327\331\371Z,\2519\2244\242@\322\031S\330\362\367M^mt\035\025Iy\245+S\3127\n\252\246\204\017\177\226\203\345\364\n\027/^\246\207BhCC\240t)\2717\027m\351d\364?N\026\210s)\360\304(ig\301y\361t6\351\350\231\275l:\032\251.\262\344\272-\250\032\2755Z[o\273\177>\320\251\306\016QsJ\031\211\232\303\031\214u\312\244J\236\346\025\327\\\205$\211\220\000\254\252\272\344)i\204Mn\2605\274\332d\367\323\000\270\226\302\r\033\036\214\0264r\254j\223\032|Q\022\220Z\251\243@\330\026\026X&\307\304\310}ksGL\366\031P\314\214\034\3034\332\353\034\311\236\000c1r]\223\236\003\317\364\375uUQQ\363\036ip\253\216\030\302\252\253\025UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUb#D\250\305)!3 L\304k\362\274\376m\255[\312RO\315D\304\235\016Q\251\351\357\343X\036m\313\305UUW\034yW\223A\354J\006\254UMmUUTUr\266\252\252\252\242\242\257=\273\034\376O\207OW\013\266\305\016\006C\023\031\\\226\342\237\335\237\220cEUTW\270w6\231\312\363\313W6\252\252\256l\225Wb\325\301-U\275~\316\372h\202\212\252\352tw9\376\201\237\213}\2649{\217\305\315\256\347w\221\336\375NW\300\221}'\342i\355s\0228\207[\025\332C\243\241u\256\227\"z\307\340\236\016\342M`\374\267\214Oa#\331>\326\367\006\262\331n\367@D,\356\274l=X\301l\024\375_\226\372\370\n{\3777M\214\271k\322\325\352\223k<\342\314oC\206\024A\322\264A\331\330\250G\034Z*q\023\377\275\320\351\200\344\306\371p\275\0358V\366\014}""\271\0207 \341\337W\227^Js&\030\252.M\273\241\367fz\021\376\017\255\020\\\007\265\226 K>!hY\017\345v\031\213!|\340M\023h\234Y\023b\254\317Wz\273\373\366H\365\006\010t\344>HH\004\020\347\347\341\346r\310\211\001\222\034\216\306\372\364\363\303\006\242\006\276\205\367}\360i\250\256\245\345Y\034\264\375\277\267\256\214\314\312\324=\263s\267\313\264\337\020q\006\006$E\223\266\017\031\277\037\230\210\317\023]M\346\245\351\371\0247\326\240\031)\232k\332\230\324\355\306\037\024k\253\003\372\200g\245\"\250\230K\003YY7o2M\027\025\215./\311\3068*C-\3000\2202D|~\317\024\nO\262|T\001\004\341.\204At\210\347+\221\242(n\324\322\333(\362n\017\030\211\276y\323\330\303\303s\n\324\301\000\347\"K$\350I\246YL\201\016\214hB\013\365RPf\332\256\266[\000\2654/c}\235G\211\237h\207\246A\003\322\346KLJ\322\324\311f\241T\315\n\333\n\2226s\237\201\030\312\355\264\371\305\2413!\302\211\304\345\303\335\026a\230\007\210~c\343l3\227\017\n\352m\023H\221\322\023\355c\315\226\021)J\025:\2131\2105\205\203\325D\026_7\301\356[\223\351\032C\307=\035\240\237\031<\276\276FqY\335\353&l\361\200\364)\273[\212\262\357\242+\311\217\245\231:\340mG\364\371%\201\200\243b\037\033$\030S\222\256\331\345\025\3130\221\007\260a\220\357:B\tXJ\344\002'Q\325\324\235Ju/\244\016\264=(\372_Y\351\354\370\333Lm\264\202\231\273\024\002\223A\226\262J\222I\202\222\032\225\254\306""\324\244i\353M\000\325\031\320\370<\272\017\013{\261u\177_\270\312\226\237\020\323M\177)D\323.\346\332\214\305\234=\313\317\331\251\321\207\263IC\213\254\353\2764>\265Q>\217m{P\2421\333;\324\226u\227$\264X\350\3006\233_\334\224\270\264\302\034\276\3544\260\375{6c\231\004\337&9\3572q\233\305B\014\014\215\240\207l\366\356:|\275\326\200vDqJLE\005\357\321\262S\261e\362]\330\347\252P\220}v\000\220wt\350\350\210\266LL*\337\002\340o\352f\356tR=\352\332\201\006L\314\216T$DeW\223\364\217C\225;\315FF\334\274\223\267\227\276v\242\264j\334\347\025\031\025UD\025]\270;\244\210'\322J\024\"\250\014\242\243P\307\204\304v\236\203\344\301\307\352\362-\315\025\353\212\275r\276\354\022\020n`r\233\370s-\303>\"\025\253\263\206o\330\222\254\222eX+X\016\2264\315\277\030\324\263\026\214 \354\026frU4'PG\220~L\254ji\271jQ\005\206&\2626\311\302j\271g\n\207\336t\276=\251 \235M[\276x\320x\327\215#\232\026\232-\023\026\264L\035D\352\016\031\347\023i\n\202L\024\020\305\0034H4cq\254\262\024KP\267D\224iU\003E\322\357=\251j^5]\255\340\336\333x\272xp\371d\234\363\2171h\302\322\325\025\306 \215,\363\371<\223\311\003o[\350u\236\311\036\352\212\253\256\205p\345R\325 \332\262\335\274\204=p\206\352\202>)_\250u:\t\204\306\367\241G\370i\360\327\344^\327Z\013\007K\031\254\324H\0143&\311\302\265\224\361\227X\326\035mev\3169\247\316\t\342kr-b\241j\020x\342q\304df%\231k[\034F\233Q\252\222r\353\242\350\201g\016yl\361\2211\"[\323\347\263\367~v\343Q\241\017.XH\234m\237\312\307\243\300\275z\370Px\327b\372Q\3176\014\203\311\177[vi_\247\227\t\366\225\312Xh\373\227\251\324\202Fmz\332\036xL\204a\346\205\030\200\310v\314\332\341\236\010\251B\216\352]\357u\317s\3048\303\005&8v\330\203 \200\307\350\360\313\303'.\247\255a\r\000&\250\021_\235\203\243\277\342\3538\317\010\212cJ\362\030k\034W_o\262\372\310\352R\r\327Dz\324\2056!\205\262E\021\223\240\242\306\306\300;\nk\272\346\276""\272\353\274s\231\264i\207\212Hl\320\243NlZ\221\t\215\024\025D1T\032\255@\320\334\360\200\261\304\214{\t*9f)\212b\3256c\256\246\\\354\271Xa\022\300e\206`\331\035t\245\2147\035<;i\225M\246\376\375F\371\013\315\332\001\2603\240g6&\300\330t\r\241\257N\207\214*\362u\322\205z\245\017V\201-\022\005\241\244\352\"g\224\211 F\021\364w\201\341q\362C&\270\207\263\330\312\216S\014A\326\321O\025\340{\002\366\374^\305\223M\252\262\027K\270\030\231~\376\224\311\031*\245\365\315\031\305\2504\024\001\3100\274\002i\252\036V\034\266<^\177s\351\320\232\261\266\334\223\303\004\003\203\020\342\321\033\2028\262X\252@\260e$\033\230oR\245\352G\244\330\006\304\335f\307\325T\310R\217\035\311A\326':3\315X\010\230\030\331!k\2759\371.\031\257^\275o\236\233\372\263\324svIu\335\353\014\226\031\262q;!\334\233\020 \016\342Vd#2\030\245\211\261.\317\005\202\326\356\261\335E\263\224\224\320\371\224\027E!\032\360\243\213\272\010\356\373]\213Ru\357\231}\375\270\352\244\014\"i\006\035D\325f\376_\022JSI(5\321fL\035\334d$\255\322\201\242V\030L=\353M\236\374\365\275i\326\366\030C\323\203\303\315\t\316{\324\204\225>\243@\350\343e\371\347Eq$\347,WJ\266\t\225M\001A$\303$A\214\322\024\231\211q\251\201u\200\352l\311\227\312@\037jv\233\315z\343]\343\321\177T\360\247\315\254\311\230a2H\026Xt\t\324\233\2753\245.\273i\274 \2060\202\215\n\244+!\334\317\275\233\315_^\033\334\034\003L\205A\326\257\250\353\352\3511\350P\357l\225\006\3006\211\035\254\332ep\303\315\311-\2115WPk\317\323\324\342\203\017t\3578P\340\037q\234\027\037\262\214\007\306i\246O\266{\213\312\277D5\320\231o8Al\306\310&\310F\314\204\257\257\326\3269\206_\010EZKv[\260\0313\030~t\253.71\237V;\222\017\027lQ\223\372\264\327\307\325e\027oL A\237\324T\362\324\302\223\232t\2030\304wO\324-[\332\356\302\014\373\035\216i\037\266f\226\315\224q\372\034\2533\333n\250\305\353\265\t5\234\217\026\350zA\316M\036\246\275\332\2143pT\310\375d\020\237\\\301\304\263\0359\240\212i\005\232t\366#0\223xZy\006\242\212i51\251\233H\325mYs2\262-\036g\3636\016\342\340\335\301\3435""\221\342H\357\246Z\257\005]\324*\253;\036F<\035%\373\"v\276\235\363\014\363\026\227\264's\244\330\241\323\342\351\340\024\231\223q\255\006\016\3720pbC\365\270d>\263t\"\233\357\277g\360A!\310\350S\265\324\306#\030(\260\004V((F*1\025\324\354\006f\251\301\3116\352\rT\372\210\300\355%\330\003v7e\203?{\215b\007\273\362y=W\203\272\001\220\002\036\t\003\322\260\227\n\326AeI%\025\265_\006\346\272\2044\237\227*\004`w\222\303n\212\213D\271\010`\030\000\254\2201y\3639\303\022I\014\322P/\253\021\200\237\"\326\200R\260-\005D'\302\004\361!\316`\\\327\250\003\274\021;\303\336<\007mUc\353\026\2121\025\236\2628\244\\rd\305\264\304\262\300G'\201'\301\030B\247\200\367\016\366\240m3\372\220ht\360\233\341\031-;;\367\\8\035\350\010'\230\243\205\352\256\255\330\357Xk3\223L\344\035q\346\311\356\247\267\223\261\304\003\342\342\023\206\213\"7F\302\021$\2340\233\315*\035S \034\204\377\247\333d\306\013L\222\005\347PfN\300I1\371\202\227P\256R\216\036\372\025\334n\0254Cj\235C\324\207`\035\253Q\006\261\271;A\261\201\330\204?\340\200\325\033Y\001H\001\212G\210\226m\275\001\376&\363v\266\354\265u\2147\274l\017\343\225\210\225\205a\013F!C\326!X\223\205~\374.\306\220\370\030\321\273\315\272\013\206m6\242\216\037c\000\201\366&\3178\206\345u=\301\352\354\232)\t\304\247\205\346\362\312\244\361\340\335\217V\252\2264\177\\^\346D\324\006<\220t\356\315\007a\343\036\266\211\236\241\277\255\304X\353\343Ov\333rl\236\\6f+\235\016\020f\343\255\247\265\352\321wvx\272v\213>\266\2456!%9\203\335\307\255\247E\332\223\265\021\253K\034\222@\237\022\222W\00393\245{v5Q\273\305\373\007=\267\364\333\335\203\207\336\333\217\223\256\373\310\257\262\377s\3664\177\265\366c\\\206\370\034\274\035\264\274K\302\024\2451\372V\266?S\024-l`\215t\216X\205&P\317\203\2756\337\213\332\272f\354\262\311\3754})\030\331\232\337#\322\323\254T#\304\2262\224yF\373\342\023\305\265\315\337\343\312\177k:\375\352[V\332\360\3337o7\177\311\340\371\022\024N\367\205\024\032\021am=\"\360\\8N\n3\322\014,\017\"\352\330\337\255!,C\022\250\215\300S$4\306""\366\351\216\304\215\\m\274\021\340=G\246\361\233\024\221\303\267\242 \365\033#\0212\254\232\300\373\275\2653\3417G\r\344\332\001\2444\265C\014\206\344\034H2!\265,*m\313'Y\003`w.\331\036\030\351\371\237\036\0033_r\003\201\202\020\337f\224\242]\234\221\034\362\276P#d6\001\356(\262N\246\231\300\310\316\230U\253u1\036\372\016M\030X\261\336\274\245\200\260\270@7\332}\257\261\361\365o\331;A\312\234Rc\t\3329Q`\0216d\244^\231\202\343\237sV\320\251\262\013\317\331\207\233}x\272\246\013m\333\024\010\303\245)\242\026@!\335\305\322\211\231\317\214\343g&\205\225NK\242V\030\323\273\314\252\t\231xDh\314U\230\324\327N\234\354\255.P\t\335#\364\274I\036#\354 \240+\3104\322/\010\274\244$\223\rw\260\364\003\253\300\034\031\006S\372\t\323\220*P\035?L\002\210\014Q'\337\325bA\351\260P\036'\360\305>M\300\226E\210\344\344\324\025,\007i\276WU\350Pv\226x\214XHF \311! \300p;\013.S\246\025\246|\365UW\334\340\273\303st\356\2627\035\310\373\304\020n:\210\tI*B\210H\234d\n\220\214M\310\033\272]\206\341\023w\332\336x\316'k\367B\307\200\340:m\331\n\267\034\221\317\233\032\231\030dt\236\257A\317\010IQ|(TISOhJf\007\030=\001\320t!\320x\250c\316I\225\341\363\363\365]~$\223(\006`&b|~\016NA\264\362\236\2238\363\337\036\007\300_\276\3538\010\351\\\211\241\340\252\364\343\313\364\213B@\267\013u\322L\023w\020\347\311\243\310WWT\004\322CI\322\362@\362z\337z\373\233\237\227'd9w\267\202\361\035\023\231\023R\023Q\316\272s)\2247\026x\250`\332[\330\324e\363U\324D\361\302\246 \276\216\235*iw\030\\&\356S\344\tMZr\027\033iB\354\321\205\034#-\304\207\204/\251}5\362~F\217/_\252\260\311\242\252\213\3048\325\276\260\276q\203\257\221\300`y\271\017\224\240g\333\202\267A\227\222\2259%\356\377uE\212\030\306\3049q\364\274\347\312\363k%\230k1\2359m)QX\336\227\254""\333\211\027\020\223\232z0\232{M?\220,\350MT\304\330h\227B\270|+d\377\004\376?\257C\346\264OBj\310g\353\353\215u\261MD\313&U\204\313\202\301f\213H\211\252\256\325<\274pP\303T\r\240,\200\315\002E\nT\331\311\204\\\")77w\026\017\370=\023F\205u\377\215\000(\032D\017\367\200\270\"4V(@P\212\021\025\203.\366\321\017\371\010\250@\212\204\"\300\024?\225\210*|_*$\374Q<\247\374\331\022\034\347\331\215\213?\315\212AA\210a\213\002H\307\350\366\263\016\320\303\342l\361\375\313\234\235\345\"\210\231\265\\\244\201\024}\006:\330C\376\361\177\370a\3758\372d\000\301\000\312@\313\253\024b\005\022\"`c\222\0352C\221\314\237j\004>\210/;\366\245\340\t\350\260>A\366\037\333\332\376\251\360\232[L\322\332\345\205\363\024\213\n\340Y\363\025\271\177\274}\356\345R\366\275p<\020\t\256D\006\010Xd0F\300f\2201Z\224~\324?\250\002\037\237\177\360\002)$RE\010\007\370\241\020\006\314w\024&`?|\2079\203n\031\200\372\007\370\300\252\235\303c@\363\246\346!\246\330\002y\322\t\265\027\226\276\360\004\276\321\035\231En\205\t\201\003\347=\014\277\030_\n\204\000\004(\221OB6\347\275\023\266\252\303\000\214\320\203\374\3165e])\256\017\354>?\336\371\337\\\r\017\367\320\t\001\030 \361!\326\300C\307~2F\362\016?\"'\017:\317\360\366B\341s\270.\253\200T\247\320\315_\225;}\330\000`\001\030I$\177TQw/X\241\213(a\334:\007G\323\223\324\303\273\352\307\304*%/}@\365R\200\332\201\211L*\242r\300i\357\211\"\037|\262\223\241\370\177\327?o//\373\303\245G\000\021\316D\370\272\242:\243\302\020I\246\001\002\355\034O\253\270RB\032\000\201\245\000\207\034\000C\210=$r\241\361\377\327?\314Xd\237\332Bb\253\377\nN\243\025\363\337\333\327{\361\276W\313\375\334\303v$%\320\300\201\233\253\253\257\365\236\337\316p\202_L\teA\334\347 \223\007\001\020\207\330o\377\354{\306\375\262\304AR\330\377\345np\313\036\030\324\276/\203\201t4kE\253\211J\006\356\376S'\200\020\276\006\" \202 \210H\205\204\240\225\014\220\250Q\272B\207v\341\204\"YB\327\320a-\027\001uO_\376\356\357d\355\014\026\321\247\314)\364\315\365\033\357\255}\347\016\245+V\031\001\t4\024""\340\034W\335\016_cd\3367?\3062\351\313\300\001\002\230X\247\006%\357\333\201\341\300\006\232,\214\300\241V\356%F\240J\023H=\035\354\262G\316\016\352\033\226\206\321\376f\240\ti*\343q\314\270\3600\030Z\373=\035\375\323\035\003\266\004@\230\346\324\373\264\030\214l4\226\206\372\030\320\320\000M\372\365\272\236~\344A\274|\342\375\360\004\234s\227$Z:\366\234X\202o\302)@\262\331\247\\\347\247\311\031`\370w\3442\026\020\353\217\345\"\177\237\265\341\333\001\217\034\264_\2242\376\013aR\227\312\\\0270fp\024)}J\225ms\302\247?r\003&\344\246@\020\2102\034\024\242\220\035h\251\034\007^xhg\246\177!\213\314\000\254\365|\035]W\317\221\223\374\343\205\030\274\3228\007\311\332\227\314\307\312\360\221N\035\037\314)\336n\305\353:\276\006\014\275\253\246\271\246\334Q\203\205\032\030\245\226m2uP\236\210\233\306\376|x\336\031\313K^\027\241\014\3058\000\317[\210\304\316Xw\321&I@\316\0312\305\010\253U\206\303\034\027\0263!b\363\242\345\204\201\337\310\024\3701\2313_\227\n\336\336\204\036\372\001\211\010Q.\200\276\344\314hI\006v\353\336\200n\300p1\275\376\302\te\201\242\373\371\024\312A\233\006\3163\352>\315\376\304\207\001\004vxz\327R\221`\341b\344+d3\226\316\373E\306l\3313\367\323\205\207+\343\317b\023\006+u\317\271C8\342';d\336\307\275\263\215\000\312\031\212\020]\236\205\030\316\226m}\340\216j\371i\274\304F2w&)\226)\324\2113\tst\366\201 v\221v\364t\375\307[\0351{\310\241\023v\221\t\351\227\231\004\250\363\037'A\265\316\306og\255\316\177L!\346\"\024o\216D\376\304\216\302\376g\355?\265\356n~\217w\231u|\340N\030\215\017\234\345 \r\326{*\3641\3267\301.\202\010]bn\243g\215\227\030\336\244\027\314\303\215\222\215\007!t\265\257\301\300\336\247\337.\310\2448\221\2441\004\232Z\036\337S\270\275_\221r\027\363\257E\t\024c\240\"$\021q\244\"Oo\345\303\335\3067\333\310\240r\007#(\375\216!\353\\\341\026\006\003\257qr28\352\271\226\222\"\\h \303/w\007\3608D~\256\177\027rf""\343H\343\177\032%NG\002_\013w\270\225\360/\217E\344H\242\021\037\311r\350\016\272\327\205\342/$4h\217\353K\333\366}\367PzN-\256d\034\247(\034\212B@?\263\327\377\245\340\033\211\334\251r\234\242\344\202\210\010p\240\267\235\350\177\n\016\3563\215\005\362X\306\001\310\320\266\r\334\313\201^.%t\214\341@\344\216\351\227\320\357\322\342\374\300G\022\006\2721!\032x\031\226\025\217m\253k\205}\341\302HH\234+s/\236\205\276\333\212\342y\005\020\340\030k\003\2504I=y*L\232\346\304|\235XA\317\240Q>\t/bZ\317 \366\236{k\352>\222AI\310\0369z\226\231E\306\253\016(\230\263\224\366D\366FVYj\311\274?C\310R@Y\374/\030&xT\360*p@\331\007\300\203\350\200{\302\374b\036h\t\315D\367P;*\037\255\007\333\0004\200x\312\234dO\024\036*/\210\017x]\260}\360\017\352\250{\"\233H\033\240\374\310\373\240\364U\345)\311GQM0{Hx^\266\364zq\275\036\3057d\324\212\223x\t`\022\352\326!\211\227\245X9k\032\262p\313\307\260mA2\325\352p\345\271rX!^F\244\273g\"V\335\210\022\274\321o,\206\222\005,\212\313QX\204\033\030\206[\314\333y\207\036\001\005\241(\222F\350\2617(B\205\361yb\305\n6\205[\005Z\302\255B\352\324\244\000@\r\273\037&\316\322c\032\342pL3\212W\032`\3041K\255""\306#p\334\025\303\021X\301dw6\233\331\2511\235\370\351\212L\204\2404\031P\225\010\010\010@$l\r\316\202\205\033\302\327\021\230\251+\310\0218\254\026\302v\220\210D\332\010[\252\033\232v\257E\300\322&[\2324\243\212\303_~\354\361Dp\t\340\234\227\306z\211\300\306f\240\020\300\020\360<\272\314\351u,\222Cw^\032\350\202\204I\2102\014\203\n\2248\262\315\264\270\302j\342\022\030p\225\300diG`\004k\030P\224\310\005\201d$\230\270\345\2634\215\315\323\231\272\334\254\260\2066\300Hid\202\010-\004\010 \202#vR\205\303.\332\334M65\234\223\261\375\264ym;=\234u\244\306om'm\014\016z\370be|\327\303\232g\363\022\237\327\214b\034\250\\-8\270T\3277\007M8\016\007f\261\321\242\207CG\274\227\275gw\277\234\025\250\252\247v\325\317WVL\235\353TS\347\374\337V\273\363,\351\340\177#\312u\232\363\t\022\221\263P\360\245\313i\216\016+\305\306\005g\030\303\272\261\336\t\014,\303C\261\256\020\010\2468W\267\300\342\200\010\344\221\233g)\213\210\027@\014*\024\356-\311\255:{\231\021\247q\356\351\032t\006\021\005Z\016$\016L\274f&Z\013\016dBK\265gv\324P\254\275\265\252\305`X&B\236)2a\317\";\245c\215\266\270A\324\036OBx\230\331#$\200\034\301\246\204J\013\277'd\265\265T(z\241K\001\315\177\032-BEH\205E\005\240\322\212\022\nR\010\021\203$\022R\310\024)d\n\026\220(R\311,\264%%\262Y)a(R\220,\226\310\024\226\302\026\026\200X0\214-\220\262\330K\031\001\004\200\226\204\245\244\2260\022Z\022\301\000e\241,- P-\200Y-\204\260d\020\022\010\036\375\222\304\2031d\224-\222X\221\nY\nKHX0\022\322\025 \202B\244)h\026[\013l\226\361\014\004\301\217\222aZ\034\262D\2360\2222q\220\220\227\214\014\204\207,\td\345\241+8\271jQ\nj\001.\242\300\323I\t\0314\221\221\362\201\030\030\337\267!\334\352\355=\371\234\343\275\236\274\006]u,\022:%\354z\275^\257V\236\247\325\347wc#\300\301\337a\231\231\233\005\217\315\277\006\370{\274\337\003\242 \311\374\\r\265\366\364\361\177)=\361/\303\236\017\357\346<\360gE\374\333\253\323\242I\271\021\233\370\340\340Y\313\214\307\226\267?<\\\315\315\036V\264=L\030\375\221\357\302\316C\221\337`f\031\231\231""\266]OQ\306\206\357\227_\311r?\005\\\332\334V%|\207\377\213\271\"\234(Hz\206L\267\200"; + PyObject *data = __Pyx_DecompressString(cstring, 12652, 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 (14132 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\226tv\005\264i\006`\356\002\334\032\023\211E\031`\315r<\013E\346\017\246\262\345 &@\275\307\231.4\364F\033\327\352\335\321t\005\243\311,7\237\0014\266\357\220V\213`+\374\030K)\356\254\214\360\310\177\303\247\021!\335\232\365\r\365o\272\\\007\256}g\272\361;\323\344-\214`\001\215\\\346\272bw\361\0204\204C\n0h\017\374\032\021i\231\330\246\026\312\200A\205\031^\237\225\033\262\262\303V\366f&\031\341\341p\240\263G\330\217\025\303\221\335\002KF\343\277\314\003\304\214:\246\312s}\236\031F\334z\242v\356p\377\024\017?\347\277\314\034\372\267\343\355\215\241w\227\2778rl\357\267\234\232\333\336w\234\314}\235\357\316O\357;\216\357\205sgs\333\371\216}GW\256\013\177~\310\007\363;\205\371b\260\230)\335)\237\257\234\252\334\252\274\322CO\364'\252\256n\352\233\t=\361Z\177\375\217\376\317\233}\307\231\334t.Y\200j\216\356\r\265\367\222\023{\352\341\276D\250\373\370\336R\276'\177\267p\277\030.uaq&w%\177*\377k\341\347\202\262\357\370v\357YN\323/\374ZJ\225\341\342\t\375\304\377\362\333\205\316\"v\\\357\272X\030)D\213}\245\337\312\321\312\345jG\365;=\030\321#\320\234\270\036\207\346\274z\367\305\027\257;&l\220L\330\374\230\370m3\230\314\330f1\231\265\315\331XC\365\263\375E\305l\351\204>\261\254/\277\322_\275~w\343\000\274|\273\267M?\255\220\223\324\223\377\300\353\336t\370\360\255>\243)\213\230,\332\036a\362\310\266\201\311\206-\216I\334\366\014\223g\266\347\230<\267""\355\332$|B\203\240\235\327o\274\033lg\330\272s\320\265S\271\036l\343\205\374H~\2650Q\034)FK\227\313\235\025[\345b%\256\007a\364\240\3070z\330R\030=x\351\337\266\007\370\356\007\266IL&k\032\273D\rJ\024\030\332\356\353g.\025\246y\233\332$\245&-\221\206\017F\000\250Iz\023\016\320\320p\273/\3711\277\\\370\262\260^\\.9Jc\345\336\312\317\025W\365\230\036n\330]\305 \205\313\005\325x\223\343[\375\333_\nCT|w\354\213#\247\364\256k\305!\275\377\317\262\252\377\345\257f\365\360\214>3KO\336,\r\275\205[\357\345\224\\8\337\205O\335\332\333\316\331sC\271\211\374X\241\347\255\343\253\177\237\355\255\344\316\344\242\371K\371\347\205\347\305\335r\307~\347\267{\031\270c\024\033\376\326qd\277\363d\016\200\210 %\037.\234/vA;~\371\255<\364\256\367\203\247O\376\257\342\317\305\251\272\371\0035\244\000s\013\205\215Rwi\266\177\2550\r\334\251\267\324\263\337y6\267b\334\375}\376\227\374t>Z\000\350\271\\\232?\010\r\271y\353\335\325\003\210\032\t\203\377tA\343l\205\313\305\316\222\255t\261\264Z\236\250\214T\242\325~}vE_\211\352\321-}k\033:\234\352P\260\337\212m\004\223\021\233\314}\0026\253G\210\215\337s\330\214[\267?\212M\377V\036.O\327\261\351\336\242\255x\261\030+\275\2049\276ZU\252\013\315\032J\243F\303\265\200\311\202\355!&\017\201\001Q{o\224:\204\tyZ?\365K\3416\276\350\253\1773{\367at7a\302\002\302\243\320\332!\344\004+\271\256\334EV\274\231W\363\377\024\247\033\002\337}\371\305\221\316\177\263{#{\3130co\347mpi\030\006\000\246\347\366\273o\2768rt\017\030h\347\336\221\275Y\230\254\236\374\\A\001^\334\t\315`O\330\200\275\036C\034\250\3729\300g\261\013h\330\344W\277\336m\223_q\201\266Z""\234(\215\224\242\345\313\225\316\252\255z\261\032\327\037\256\351k0!3z&\013\250\3301h|\014\2231\333x\235\014S\336\r\177\361uW\316\001\214\037Zx\237\270\347\261\013\200\217c's_\3452\372\205;%u\377\344i\375\364\345\302\032 \244\373|\376\233BO\341O\030\330\356\237\2006\257\024\177(M\277\245l\027\334\230\033\332\357v\026\276*l\003\242\241\237\351\\O\356\317\302i\250\364\344\031\306\372Y\212\214\363\344\271\334\366\333\223gq\212\025:\366\257\337)\255\224\273\312\203\320\217\236\375{\367\367o\334*\271\241\334\303\260\n\230\351St\005\370MV\317\356H\242\366}\311\356\006\314\203\201\362\233jR_z\274\217L\333Y\350@\326)\347\271\210\316\024\356\025'K\231\362\235JW\245\257\372\207>\017\310\335Aa\333a\342\023\222q\213g@\022\266\255`\262bK`\222\260\355`\262c{\205\311+\333kL^\333&\354\250g\330C\230\204\354\213\230,\332ULT\3732&\313\366\025{\235\034W\220\225\260\221BA\323yl\317\007\262a\033\007\353v\341XQ).\226;\200\027\002\316_\000\003\031\004\364\237\354\006i\242\354w\367\027\307KC%\345\355\311\336\342W\305\355R\007\307\251\362\356\004\r\375\333\316\013@\300\217\212g\212\033\200\362k\225\351\212\272\377\203\263p\242\250\201\272\244U\206\360\205\303\205P\361H\361\021\\\377\271\254\300\304\275\330\013\305\231R\017L\206\257O2\261\244 \227\332\306{o\351WF*=HP\267\241z\027#\230[@\020\016\240:\240*{\356\327|_a\010I\342t\356V\356\005\260\301K\205\355\375\3563oOv!\355\000/\005\336\nD\335\261\177\356\374~\367\367\372\367\343\225\355\375\363@\223\320\231\363?\344\335\360@\017\300y%o;\217\352G\177\312\257!eu\347\036\300\024\315\026\374\300\244\217])d\231p8\316\250\261\341\305\357*=o!\233)\336\002\264\034\001:\206&\337\334S\367\376\311\207\nv\326\302c'\365\223=\354}\307\260\255\333y;k\305q\340\255\271\237\362\031\375\227\337\313\nV\2152\371\313\374J\241\273\360\020\252r\224\224R\030\307\002D\206R\341\263\"\307\356s\303\320@]\247r}X\317\333\316c\372\261\237@\363@\366\207\371\037\362\n\"\364\370\236\027\245\303\3761.\333\027\201M\\(\001~\221\244{\364\323\277 6k\356\373\001$\305F\261K\277\212""\r\202\362\031\230\036\377\200TI\300\270s\275A\242\037>D|\360\266\215W\357\037;\223\233\311\017\320\324\325\277\375_\376YA+\016\341DWA\t\001\034~\227?\0130\340\003Eu\277\253\247p\016h`\272\346\362.p\360+\245.\020e\214\201\340\314\004R\235\312\237\001\211v\254;\347\322\317\017\026\325\342\266y\025\333p\032\030l\234MSbB\033\330\251\323\300[;\013G``\217a\007\356C\017W\221h\316\3452l\020\240\227\347\271\250\004ez\372-\243\254\373 \366U\030[d7\271yx\342\251A\362\307\365\343\320N\201\352\361]\267\366\2629>\310@v\373\235'\366\264\334]`\030=\374\032\316#6\303NA\373\220\333\030\2446S\354\331?\371=0\233\333\205o\261+8\256?\002K#~w\033\251\004\333\371\006\332\222.\366\000y\355\000q\235<\247\237\353\003~\177\251\370\232M\241\253(\236\256\016\203XV9\221\262f\013\3256\251m\250\276\246!\320t\000\003\247s7\241\235;@\275\035\2053\205\225\342\271R\307\2770\374'\255\356\202\330\311=\303\221`\270\203D\207a\354\20218\216Z\314Q\030l\270\362S\376%t\220\021\337$\014+\336\364s\241\207\337t>\377?\240\306n&\005\217w\345\216\344fa,\334\360\266(\266l\037[\006\335\202\346,\224\201\305\377\010z)N\0366\321\267\365\363\275E;\322\323\371|\207\376\3355\375\332\004\030b]8R\217\340\256A\300\006'\\\024\214\300+\232\277\001T\255\222\253\3745\316,\363\rgr\213\320\353\237\020oT\tN\354!\336jV\356c\223\010\310\244Q\225C@\262\027K\2612P1\312\262\036\340\260'q6\364\200\222\331S\374\253|\261\254\3425NTI\240z\343-}\210\014\342\250H\351\n\022\356\235|W}\362k\276GH\356\242\210\255\005\336\316\303\200\275\3534)\024\333\212\335\272\000\354\235\351\020wr\247\221`\221\340.\200^\261\010\250\3562\330\271\365\330\261=/\342\372(\030\227\0071\007abX\317\237\315\251\300\232\366\306A\226\263\251w\023tm\300\307y`q*\314\007\034M\375\334u\3163\367\273\277cM\t\003=^c\3526H\034 \227\375\2563\271P\376H~\332\030_Pu\365+\367\312g\313\333\300\330\t\267\177\302CWJgK\333\345\016\344\275\360\272\357\362L\204e\364\323\027\251\322\036\034\344ic6\334\001\211>\3049\356?\205\005\340$Y\350C7>\325}\016\324\376SLI\003i\341,8\230\336\005b\343""\226\376\277_\341\r\307*\312\376\017=\014\225()/`\361j\261\347-\023Sv\336\325mj\230~\341\032\312\004\203\364\0019\307LY\t P_\220\266\020\321\243{\257\363\036@%\362I\211\275\031C\364\220\261\037\250{'7\253_\030.\375\0028\272\203\224\213\023\270\027\212\323\373]\347r;\372\217\277\226\322 \363\276\004\331{\022\324\263\342|)\204H9\215\354\036%Q'0\350\374t\375X\233\322\017\010\373\033\213w -\035/\314\002\263\240,\360,\351\271\023{\033\2004\2135C\275\271\343\371\260\336\203\2702U\204o\352\357'\255\003\357?\221\327\n\277C\377\216\262Q\347\232\332;\0077#D=\366\250\221\371f\357\032pwP`\217\355M\212J\333\235\302Y\306\375$\035\356|\371\373\312\255\312\363\352\013}\001\2147\260\001\300\014O\353\351L3\325\356Ni\271\314,\236\237\004\203\0025\227p\361\273\322\265r\270r\266\262]\375Z\237\206\312\236\350OV\365UP\347\300\254x\251\277\344.\027YW&\333\207L\212\010&\021\233\206\211f[\305d\325\226\304$i(u\377`\362\217\355\001\352o\017\354\223\230L\332\037b\362\320P\352\342\230\304\355)LR\3664&i{\306NJ\371\265\"\271\017HPO \367\205I\007\364\371X\177\014\362\202\323'\331\375\304?\2661\331\266\215c\307\306\355\021L\"\006s\177\200\375{\340\230\304d\3221\207\311\234c\036\223y\307\032&k\216\024&)\307.&\273\2167\230\274q\374}\004=\315G\224#\234\0106M\317\362\333\221Q$\330\343\006\363\251\341Bh\273\010\250\232)\365\226\257V\334\325\246\364\333_\034\001S\256\006\013\347\341\266[`\310\035-\335\266&\352\274>\017(\210\350\021 `\346\205A\266:\212]\037\265\021\035\223\037\204\320B\262R^\254\330$\252F\003\317\352\320\345\303\033\373\353\305T\251\316!\214+\010\321B_\3617\346+\353\250|W\275\246\317\034n\207\204E\207\253hY\367\266\267\354\200\256\352\263`<\247\300\212\230-\335-\017\203\232\362CuI\177\330\322=;Z\357\235>\224\227\302\0335]\333\326\267SH\274\035\346\333\010'u/\2756Z\031j\367\245\310\022/\303\200\240\177w\2654Q\036)G+\375\325M}\261\255\236\nR\353\332\250>\212\254\364@'\370A/\206q\307\256\352)sa\307\364w3f1]\377\356Q\327a\322*\372\"\353DG\275\343\3617}vA_\340\313] :v\364\235g\270\324gH\017R[\311\373H\314\2264T\223H!\331\004\231Y\267\326:\372P\177\310\306\273_\350\026S\365\363=-\273\365k\265\247\025O\211\227\373+-\370\312\255\322Ny\272\034\253\274\324\203b\327\270\317\232\206\236\244\"9\372\3471\2317\264J\342\343iL\322\206\364\377\033Y\356\337v\005\023\305>b\257\3454\240\226\262\231\375\371-\223\273e[\271\247\3262\271T\010\202\021y\2574Y\316T\356T\273\252}z\010\370\321\262\276\3145\004\240\313\327hP\030\023\202d\016-Q\313:\221\212\211j[\303d\315@\016\211%\022\273\204\034/&^\373\024&S""\366G\230<\262G1\211\332\023\230$\300\036\201$c\317b\222\265\357\030\326\311@\321$\232~\227\356B\245\355\335\360\373.*#\005\334)\234/\236b.\261\371r\020\372\376{\365\265\376\010U\"\3759\227\325\262s\335\\~G\321i\364t\031\223e[\n\223\224A\006\031Y\266\230+\315.\367aJLT.:\232\353\r3\226\200\201\251\305\303\035\236\352O\237\351\317\270\312'\033\231\024b\360\004\223'\306\370\231\263\2254\334Z\025\000\350\230\315\372\376F\330?\372\201\226\226D\353\024(\362S>\005\220\347 Qq\035\365ne\270\022\256\376\240\317@\217\342z\234\217\025\221\243\007\023OM\304\204l,\257\031kOW\n\3335\035\371\374\023\362^\371Ty\250vB^.,\027\035EOi\021\314\307\261jO\365\236\036\006\316\004\342\211/\032C}\334O@\374I\356:i\355K\230,\031\364I3\221\0141\242V\231M\321L\364a\342\263/a\262d\3270\321\354IL\222\326LD\356h\177fL\310\301\242\031|\320\357\256L7&\207\332\311H2\261\361<|\245/\266\\>4\345\"\331)\362t\313M\263\021ew\177\376\021\275\217\353R\265#z\205\2518\013\245\215Jwe\266:T\365\35030#\2412\030\316\r}\003\272\311\345>i84\224\024\315\"+\177\rmjb<\246\304A\2720\206\222\214\320\307\230<\266\257b\262j\337\302d\313\032J\3249\355\317\215\021\275^45+7r\216\306\032N\375|\026\304tK\235gC_\200\301\005\301\002\2104\"Y\230li<\260\202\33638\246\217\201\r\304\350\342\326\001t\206\213\200\216\363f\2163\307\331\302]\260\224\303\245\263\245\347\345\024\214\306#}\032\204\035o\315K\375%\017\277\222\361/\257\351\313L\221P=\212\311\250\335e\027Y\244~\364'\375\247\341R\017kvEmW?m\336J\356)4\235\023\262\3325V\307\236\337^\037\327\307\201\367s\035\232\246\016qx\020_w\017)\020\013X\223\311\205eQ)\363]YF\312\210\223\231\017\221*\031\260O\354\215\343\266\306'\032c\264\271P\351jK\025G\365\317\260\302d\r`\242\236\036\241\021\375\357=704\301\020m-]\206\315\233\"+#\363\266z\227\022p@&\023>\265p\346\236\355\331\342\335\3220\363U<\257\244\252\335\325G\372\002\030p`Kq\325\221t\347)L\246j&TC\357\240\340\204\356x;\261\214,\317\020wDNcH\035c\366\030&1\273\017\275\025>G\022\223\244c\313\361\356\316\207r\254&\323\357\021S\r_\242\273""\246\203\03025\204|8alH\330\276\216\311\272\375\r&o\354\177c{\376vx1\361:\2460\231r<\302\344\221c\t\223%\307cG\335\274\365<@\206{\274\016\377\315F\204i\216-\004\352\037z\000x&\0275\246\376'k\r\017\352\335!\320\212\336\017Eb\023V\321n+\004\037\306\203\311\017oE\223\350V\340\244\320\004\340Y\246\242/\363\373\311:\353\024\346\022\013*\375\364s\tm\261\235\342|)\310\214\356\363\325S\325[\244\r\201|\342\242\262\375\200\334M[\275\311\364\000\224f\326\357\206\213!\246\301}:w/?^h\210\325\306*\333\033\3751\014\355\216\276#\311s\232\360\324d\322I\315\325\216:\222\233\364~8\3417\232\267K\206t\332\3247w\365]\356\005\226c\204\275\215\254\032f\354\177\372\301F=\377\313\342zi\271\354(\217Uz\253?W]z\200{\346\323h\372\032\026\267\354\r2\303\231\0312\033:VD\235\3740MN\306\223\233-0\\\262\\)\242\243\272\201\026O\035!\341\325\230*,\031{\270^f\345\275}\314\r\2040\351\247\344\n\222W\357\236\324\221\365\247`\346\217\331t\0036\366B\177\201j\353\341\275\263\221j4\200\236\021+h\031f\022\274\265n\234\034\\\302\177\372y\203\326\324\331\342\363R\252\334]\236\255\334\255\016W\303\3724o\036\327\214IS\220\255\t\231\316\032\3726\004\313\307\227\353\301\000\255c\030\nb\206\336\031\341i\024\307fD\327\003{\325\007\377\256t\350\3124[$\005\362\237\247\372n\227\246\233\204\327?`1d\016\036\261\347\320\177\030d\242\322V\276\002|k\332\n\252\027\242\263O\032\2418f\0247F\233t\002Vt\307\217\371i!\244\002C\220\354\030\232y\n\346\000\362s\026Cs/\377\240\260\212\221\217,\252\005\3462Fc\032\361Jg\371\n\277\021\205#\207\370AO\277\371\342\310Y\206 \375\372H\245\2472Taf\362\264\025_\354\306\266\234\330[\203A]\315+\371\031\214\302-\366\030\354\210\341\247\322%\357J\270Z\354\321\257\375Q\236\326\377\364U5=\024\326\3033t?XMM\3206\316e\021\337\225\320e\255$N\0002\241\373\030\224\204K\215\"\002\217\026\206\n\256bg\251C\350\0065\350\034\213\373\342\001\352RGp\036t\344\317\002\2338R\230c1O$I\365\201?Y\000\226\031\213\237\033\304\031`8\224\020\364\203\376\303\000\013Lt\000\341`<\202\2657\303\272tJ?u\205\"QM\216\rw\364\376""\255\377\035\322C0\261\271\213\307R\225\357~\304\3420\256E\375X\336\304\310a\320\312\221\035\313\\\260[\357\306v\256S\3030\316g\202O\270\372\005\253\001}.\252G\267\365mi{\220<\271L]\236i#\362\23289~\203\230\004\215\310c\262\370H\231'\257\304+L^\331_c\362\332>\201\352\362\204#\204I\010\264f|\300\021\305$\352\3200\321\034\253\216\306\226\342\305\337\365\337\221\270$7\306\207-\260\017T\266\333Zb\347\313\010\\#\342\213$d\270\221{\216\306\325\224\031d\224\327\331\227\227\376\320\377\300\335:\222\207\373}\233\216\353 \233\345?\252\035\355\216z\375\372\310k\266\003\t\327\306\364m\334\340$\216=\365\205:azY\231\013\231\214~\212L\242\220\244\000&\001\3734&\323\206\357\177\r\2235#$\3519&\317\355\273\230\354\332_\330\033;\324\257\374\245\377\005\374\026w\361I\336\240\367E\020[\247/?\254\274\320\247\203\373\216s|?\304y\274\377\274~\236\207\307\365\310\360F+\364?\352\2630\354\334A{p\370\010)n\262W\204B\267<\330m\217\021\263\365\004\223'FX>\205n\221\313\216\242\027\310\262$+\330\357h\342\206\372sA_x(\331S\037\271p\210\223\"RV\332\212\036\202\031\370P\177\270\250/\002\373\000\014\231T$/\257\221=CTDR\332\\WA\255\330\226\255\237&\320\253\206\313\241u\016\3363\005\265Q\007\327\253O\365\371%\266\023\243\351\376.\345\340\335]\213z\000\2307\"\231\255\233sO\261ix\264\037\372\265\213\311\256\341\240'O\007\205uL\330\353V\277\037.~\322\336\277O\210\2308\310I=\t\242\006UE\3465!\345_\336\336&3@9\210\212\274\331f\277\331V\025\217\275n\360A\006\367\203\306b\330\354\000i\337c\335\\\347d\270j\031\247\260\310\244i\333^la\300.\201\016!\351\311\037\302\321\343\265\321^\007\255q\277\322C\357\267\323\230\3268\211S\321$$\332\2441z\331`\355\345\255\272|\270\350o\272\210p`\250^\263\020\266\216\232X;\n\357l\301\004\357|\240U,\314\215\303\265\212\233\004\2354\013T=\310\367\2358\330\300c\033O1\342|\333r+\325`\362\220\334s@\246\334C\207\246\255\376\352u]\264\310?o\332u\273\177x0o+\252\223\314LZ\264\223\2754\007iv\237\276\375\255\230\326{\315\032\213q\035\356\264n\351io\240:\233\276\342:\217\335\2416\353\360""\274\306\355\035\203\201\033\237N\025\356\200^y\212\261\352\371J\260\222\251\376\256\317\315\353\363<\016\0169\205\236\335\241Y\327W\354:\200\007\310/`KxM\317\025\230aa\024\313\3722\217@\223\344\330H\315\361\002\177\344;p-\363\372\201\357e\216\001\366\323j9S\232\345L\0305^n\243\201\276\227S\370\333/\177\354:jc\366\"\320S\273[\237?t\340\336\366\017\264\333\213\246\201J\215\271\265\340\001\374\250\027l3G4\274\203\353\n\211F\376\305\203ko\275p\0342\364\021P\024\301\262\224<\231\206\t\317b9\332\354I\223\245\324i\346\033\204a\347\207\275$\353\266S\014\014~\344\033\232\372c\205\227\374\366{\333T\205G\017\\.u\226m\345\213\345\325\312Du\244\032\325\203m\262\037\351\250\2016{\325\344\\\006PWxD,\n\013\3462\022\217^x\217\372\033\013R\025\327\265\200\306x\2576\353\243k\373?\256\376Mq\223\003\340\014fI\235\014\276\3741a\312\323x\312\001X:|\334\343u\262\262\315\312\233\304\266\315\352\263\300\224a\000\270}\221\251\217Y\373\257\027\366[\332\357\362\231;\342j\376ghw\023\266\314-\362\266\202|\314\203;\004a\373\351\333\335\344$\r\3207\321\335j\304\206\313\261\024\362j\340\343\372\263\241>}tf\023\366\016\034\353\300 q\323\336\254]\367\377\014\330\376\031\214\270\261bo\351g\266\013l\275\262\\uT\275Lr\203X\337\363\003w\367\203Z\t\352\260ib\267\261\271\215zNg\360\312'\301\274\261\265\364p~\212\t\337q\210\323\235l/y\326\313\361%\264()o1U\352\347\371\243\245O\334s:{D\356\373\201\347\215\200y\017\242\322\2649IZ\3126\262\274\341\224\366\324\322\336\003\332EcR8\035\374S\353\204<\260\3575\313\240\264\236\324\034\r0G\301V\346.\356&q\023=\207\0245!/P\313^\2466\366\031\021\353\247M\032\024XC\347]>\252\217\250\350\273\372QG\312\222\300\023\367\0006>\307s\201y\323\200\002\000\207|\354i\2527<\367\226S\362\331\334j\376\001\222g\347\336Wx4\3426;\356\022OD;\334\326\0374\177\245\34633\201\246\355\301]\240\223\"\256}T3\207J\247Ju\013\357h\372:\n\236\342\"3!{*\367\252S\214\256\370\3269\036\304MZ5q\323\206G-H\206\357\325\217jd\227|\372\220\030t\327\250\271\nzX\241\301\234#6:\017L\016#\243\335S\346aQL\nl7Z\270\373(d\267\025\343\240\2423'\254\207\371$&\321m\256\257\t\276\375\213\227>\2621m\205#m\262\306\360\235\357x\274\032\263\276\033\356\260\235\264\265\\\032x\337\366\r\327O\0374Q\273\013\013\305\rf\352\rU<\342\362\001`\212k8\262\235\355n`\224~L\263n\326O\027\364X\\,\304\212/\231\345\257T\026\304e\031\020I\234'5\334h*\372(p=\363\352G\265l\2704\2156\365\t:\300U\3146j\345f\335\tV\262\312 \273(h\252\220\212\334*\246\220:u&7\233\277\207\355\263X\354Yv\236\351t\353kt\"\371G\215\022\236\244W{\0309.h\334*\354\226\216\226o\225w*\323\225\230\264>\013\232b#>1\336`\r\343\243\033&oko\335\256&\374\353\260\333\325rO\217aYlS\254\003\367\356\223\262e~\250A\330\202v\351\362G6\246-C\347\265\034x\301g?M\263\306\373\323\232\230+\357\333\276\201z\306Y\257\235v\320\002$7\301\310\0201?\220\",j_\276\362\221\215iKY>.\257\206r\236D4%/>N\325\237\225x\245\367\2438\023\035\262\3027\305p~$""\346\233\204\201\213K\347\322\024\220\233K\026\215|FG\343\323\037\245\030\030\350\323\345\217\357\323A&i\303~\320\034\226\327 }\255#\262\336\177\267J\rQ\034\264%\245\207\202n\270\341\\kE\266B\266\271\367\374\200\250\223\367\376\034H\033f\3174\305\300\360\345\001\212\2246CG\004c\244\267\357\243\206\273M\327\323\200\034\267\304QH\226\250\274\220\350\257\337\245\rM\034<\334&\276\317\226\244\353\357\245\342\313;\014\032F5\223\337\214\366\251\264\374,B\315^\243\377\340\300\231v\235-\342)P\240q6p,\222\303\241\241{^>\245\201>&A\336&\362\262\322~\236yL\346\233\034\342\321$:\362\363`\252-\r\346\245\376\360\261\376\230\317\003\250\017\270I#\335\234f\0049\243hi]v\305\312;L\315xy\346\231$\027\rm\202\243\035P&ea-\366\250\275\265\232\364\271N3\352\371\217\3162\"\305\\>\244\212f$\221\030!\214\216\334\240\315\203O\355\255W\302>\017\336~\253?\325\253\301\027\205`2\002\225\361\0108\311\205\322P\025\224\017V$*\223\267Z\232\326\014.\037\326\034\007E\323s\001\223\005\203\312L\244a-\366\r{\353 \302\317\203;6p\222\357\254\341BI\215\363\270\201\277\234\210\255\3416}Y\001 \204\021[#\366O>\3039L\346\214\023\321L\266V\027\261\364\371\021\205g\260\327\020\031\0065\271\212_\227.\224]x\202\177e\227\035%\004x\342~:\260}@\313hd\325\313{9\tW\362\322\232\254\231\022'#\0174-1\321v^\302\225\311\311\330\251\216\232\275.Z\352\355\253\327\377\001\332\206K?\327\n\202\006\376\231E}\036j\343V\0077\262\271?Z\216A\241\251Ik1\244Z\310\256z\232\232\262\206!\357\351\243u^\242-\342gt\n&\235\275\267eo\355\014\372<\250kw\253S\315*^s\177>\36149\256N&;Z\352 \267>\3614Z\313$z#\236f\272\365[z\363>\017\246\270\343W$\261z_\357\244>\007X\342^\000\356ok\262\002F\253\036\204%y\311S\026\000\36278\211\274(\250\200\260djd\264\253\270\336\341\375_|1C\375\017\276\227A\336r\371\223hDY\264RDS\322da\3548\314U{}T\363\177\301\306z>;\023\243\255\240\346'^\031K\243\365u\322\315\032nZ_\376?\301\275\230\003\\\302X\275gyC_X\322\227\270\327\003\314r\260\222\370\272\201\034\212%\373\024\310\277L\250\"\245V>\230I\346\376\264PK\032Y+\373\262""\351~\213\317u^t\307\177tZ4\261{3\202\201-\354\323\371\220$.\211\304\350DS:?b\275\376\230\350\377\344X\337\256\377\350P_\262\236\344H\010\022\000\244\311\022\241\231\010#\353\251>`\366\363\343\355\327\322v-\336\032|/\033&(\010M\276\213\032\275\347\372+.4\345\210f\331\335\323\360t\022s\271\224\221\234\0344C\332?E\342\221\3204\005\000\221\\\375\227\270\227W\016w7j\343\355y/\331\367U\315\035\3442sj\374\001aa\215c\205\317P\262\213\210CY\307,\3349\224\366\213\237\031oy\310\251\024!*\0075\265a\316\222\013\245\261uF\353\000\374\333\343+\321\303\035\231\226\235j\375\035\0173\262\247n\271\"\312\207\306\212u\032\374l;\256\3718\320\034j#\366\310d8u\347\227Fk\317\256\032>t\212j\331\023\351h\3216\202E\211\276\032\177\266\201\372\305iH[=\\\032jyN\352{m\210\021\234\361\253k\207\204\360\272\003\264[n\215okc\211l\255\264\212\327\023\002\224\241C\237o\207\377\373\354\217\021\243\231\214\023\335\216\203\204?Z\035\022Ou\303\343\356\360\353\266x\316\034\373\356:\213\037\300\002g\311,\226`o[?\311B\232\336:\350\243\274\004\346g\323\235\310\261\023\000\217\262\013\346\007\267\256\340\347i\273\371\2276\307sCz\367\305\202\267\004m9\276\267\300q\365\325\277\333t-\307\352\373:\327%\334;^\274\303>\220K\307\335\375XX+\316\362\257\374\361\226^\306/r\t_\373<\231\263\345.\345\322\210Y\270\322\3154\301_K?\227\306\313C\314\244\205\266\237\330\213\361\021\020\332\376M\216}\307\366\327\334/\271i\374\264\357\264\321$\017\014\3046\266v\216\035\364w\206}1\223\212\323F\025\366\3340\373D'\006O\345\\\370!O\036\351\306\317\232\271\362Wy\373\243>\234\306\317\376\232nk=T:;\200\231\005D\035\344=k\274\253Q\340\214K\\(X\341)W?q\350\361r\351D9QU\016)\000\231&\0011\32164N2\006[i\234\"z\036q\364\220\225@\272\232\305\226\207?y\350\356\233r\262\032\341{\322[}\223\375\003\003z\033*7\024\273+\237\207(\373h\310\005\370\002\223\027\366\021\334\3161\342\240\363\020=\230x\034aL\302\216\010&\021\343\203n\233\230l:\022\230$\034IG\003\245h\211K}Ke\034\374\344\004\371m\371MUm\205\335\017$Nb\315D5\262G_\376\332\200\2543\222N\277""\201\311F\315\361z\204k\372x^\000\223\200c\032\223iG\320\321@A\000\211\375\271\203\254\017\367x6bMD\252\362\356ry\311\274\325\002\035\2714Z-\320\t\356Y\024S\273\354\313\307xt\353\376\327\247\230\240\300\260\272\377\237\362o\031\000H\242\217\t\343\316s\271\027\005\376\215\332\027\302\374\353\375\354\324\203|\357u\375\031\216\037\310\343\250'\255\326\334hj\312s\222\004\006\321\017\361?Z\226\334\306d\333\372J\r\035\r*\033O\377\017\013\0140\007"; + PyObject *data = __Pyx_DecompressString(cstring, 14132, 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 (49836 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__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_inputsordereddictoutoutaroondownoutaroonupout""begidxoutfamaoutfastdoutfastkoutinphaseoutintegeroutinteger_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_CDLMORNINGSTARstream_CDLONNECK""stream_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 < 947; 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 = 947; i < 1153; 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 < 1153; i++) { + if (unlikely(PyObject_Hash(stringtab[i]) == -1)) { + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = stringtab + 947; + for (Py_ssize_t i=0; i<206; ++i) { + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #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_IMMORTAL_REFCNT_LOCAL); + } + #else + 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 CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #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_IMMORTAL_REFCNT_LOCAL); + } + #else + 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; +} __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, + PyObject *line_table, + PyObject *tuple_dedup_map +); + + +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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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), 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_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), 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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}; + 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_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; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ - __pyx_t_15 = __Pyx_PyInt_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 5222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); +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) - __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_15); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_15)) __PYX_ERR(4, 5220, __pyx_L1_error); - __pyx_t_15 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_673stream_WMA, 0, __pyx_n_s_stream_WMA, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__502)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 5220, __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_d, __pyx_n_s_stream_WMA, __pyx_t_15) < 0) __PYX_ERR(4, 5220, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + /* CommonTypesMetaclass.init */ + if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_n_s_TA_FUNCTION_NAMES); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_TA_FUNCTION_NAMES); if (unlikely(!__pyx_t_18)) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - if (likely(PyList_CheckExact(__pyx_t_18)) || PyTuple_CheckExact(__pyx_t_18)) { - __pyx_t_6 = __pyx_t_18; __Pyx_INCREF(__pyx_t_6); - __pyx_t_17 = 0; - __pyx_t_27 = NULL; - } else { - __pyx_t_17 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_18); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_27 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_27)) __PYX_ERR(5, 6, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - for (;;) { - if (likely(!__pyx_t_27)) { - if (likely(PyList_CheckExact(__pyx_t_6))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(5, 6, __pyx_L1_error) - #endif - if (__pyx_t_17 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_18 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_17); __Pyx_INCREF(__pyx_t_18); __pyx_t_17++; if (unlikely((0 < 0))) __PYX_ERR(5, 6, __pyx_L1_error) - #else - __pyx_t_18 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_17); __pyx_t_17++; if (unlikely(!__pyx_t_18)) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(5, 6, __pyx_L1_error) - #endif - if (__pyx_t_17 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_18 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_17); __Pyx_INCREF(__pyx_t_18); __pyx_t_17++; if (unlikely((0 < 0))) __PYX_ERR(5, 6, __pyx_L1_error) - #else - __pyx_t_18 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_17); __pyx_t_17++; if (unlikely(!__pyx_t_18)) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - #endif - } - } else { - __pyx_t_18 = __pyx_t_27(__pyx_t_6); - if (unlikely(!__pyx_t_18)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(5, 6, __pyx_L1_error) - } - break; + /* 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); } - __Pyx_GOTREF(__pyx_t_18); - } - if (PyDict_SetItem(__pyx_d, __pyx_n_s_name, __pyx_t_18) < 0) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_name); if (unlikely(!__pyx_t_18)) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_18); - __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_stream__s, __pyx_t_18); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_t_3))) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_Add(__pyx_t_15, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_6) < 0) __PYX_ERR(5, 6, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - __pyx_t_6 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_6) < 0) __PYX_ERR(5, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } // error handling follows + #endif + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Wrapped vars code ---*/ + /* CythonFunctionShared.init */ + if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - goto __pyx_L0; + return 0; __pyx_L1_error:; - __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_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_XDECREF(__pyx_t_12); - __Pyx_XDECREF(__pyx_t_13); - __Pyx_XDECREF(__pyx_t_14); - __Pyx_XDECREF(__pyx_t_15); - __Pyx_XDECREF(__pyx_t_18); - __Pyx_XDECREF(__pyx_t_19); - __Pyx_XDECREF(__pyx_t_20); - if (__pyx_m) { - if (__pyx_d && stringtab_initialized) { - __Pyx_AddTraceback("init talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - #if !CYTHON_USE_MODULE_STATE - Py_CLEAR(__pyx_m); - #else - Py_DECREF(__pyx_m); - if (pystate_addmodule_run) { - PyObject *tp, *value, *tb; - PyErr_Fetch(&tp, &value, &tb); - PyState_RemoveModule(&__pyx_moduledef); - PyErr_Restore(tp, value, tb); - } - #endif - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init talib._ta_lib"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif + return -1; } /* #### Code section: cleanup_globals ### */ /* #### Code section: cleanup_module ### */ @@ -101652,16 +88797,14 @@ 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; n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 for (i=0; i= 0x030C00A6 @@ -101754,22 +88897,18 @@ 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); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif return PyObject_GetAttr(obj, attr_name); } #endif -/* PyObjectGetAttrStrNoError */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +/* PyObjectGetAttrStrNoError (used by GetBuiltinName) */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -101779,11 +88918,11 @@ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 (void) PyObject_GetOptionalAttr(obj, attr_name, &result); return result; #else -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); @@ -101799,19 +88938,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, P /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); if (unlikely(!result) && !PyErr_Occurred()) { PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif } 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) @@ -101903,14 +89038,9 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) PyObject *local_type = NULL, *local_value, *local_tb = NULL; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; - #if PY_VERSION_HEX >= 0x030C00A6 + #if PY_VERSION_HEX >= 0x030C0000 local_value = tstate->current_exception; tstate->current_exception = 0; - if (likely(local_value)) { - local_type = (PyObject*) Py_TYPE(local_value); - Py_INCREF(local_type); - local_tb = PyException_GetTraceback(local_value); - } #else local_type = tstate->curexc_type; local_value = tstate->curexc_value; @@ -101919,24 +89049,30 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) tstate->curexc_value = 0; tstate->curexc_traceback = 0; #endif +#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000 + local_value = PyErr_GetRaisedException(); #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif +#if __PYX_LIMITED_VERSION_HEX > 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 - if (unlikely(tstate->current_exception)) -#elif CYTHON_FAST_THREAD_STATE +#if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; - #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } - #endif +#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000 Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); @@ -101974,10 +89110,16 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; +#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000 bad: *type = 0; *value = 0; @@ -101986,22 +89128,18 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; +#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; ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; - #endif result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -102012,60 +89150,105 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg return result; } #endif - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - __Pyx_PyThreadState_declare - CYTHON_UNUSED_VAR(cause); - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } + +/* PyObjectCallMethO (used by PyObjectFastCall) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif #endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; - } +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + if (kwargs == 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) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif } -#else + +/* RaiseException */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { @@ -102150,9 +89333,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } PyErr_SetObject(type, value); if (tb) { - #if PY_VERSION_HEX >= 0x030C00A6 +#if PY_VERSION_HEX >= 0x030C00A6 PyException_SetTraceback(value, tb); - #elif CYTHON_FAST_THREAD_STATE +#elif CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { @@ -102172,242 +89355,358 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject Py_XDECREF(owned_instance); return; } -#endif -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; +/* PyUnicode_Unicode */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj) { + if (unlikely(obj == Py_None)) + obj = __pyx_mstate_global->__pyx_kp_u_None; + return __Pyx_NewRef(obj); +} + +/* 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; - 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 **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; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - 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 PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { - return NULL; - } - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { - return NULL; - } - #endif - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - 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; + 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++; } - 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; + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); } - nk = i / 2; } - else { - kwtuple = NULL; - k = NULL; + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); -#endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); +#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; +} + +/* 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); } - else { - d = NULL; - nd = 0; + { + 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; } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; } -#endif -/* PyObjectCallMethO */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); - self = __Pyx_CyOrPyCFunction_GET_SELF(func); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) +/* 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; - #endif - result = cfunc(self, arg); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); } - return result; -} -#endif - -/* PyObjectFastCall */ -#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API -static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { - PyObject *argstuple; - PyObject *result = 0; - size_t i; - argstuple = PyTuple_New((Py_ssize_t)nargs); - if (unlikely(!argstuple)) return NULL; - for (i = 0; i < nargs; i++) { - Py_INCREF(args[i]); - if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); } - result = __Pyx_PyObject_Call(func, argstuple, kwargs); - bad: - Py_DECREF(argstuple); - return result; + 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 -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { - Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); -#if CYTHON_COMPILING_IN_CPYTHON - if (nargs == 0 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) - return __Pyx_PyObject_CallMethO(func, NULL); - } - else if (nargs == 1 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) - return __Pyx_PyObject_CallMethO(func, args[0]); - } + const TA_RetCode neg_one = (TA_RetCode) -1, const_zero = (TA_RetCode) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop #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); + 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; } - } - #if PY_VERSION_HEX >= 0x030700A1 - if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { - return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); - } - #endif - #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 - #if PY_VERSION_HEX < 0x03090000 - vectorcallfunc f = _PyVectorcall_Function(func); - #else - vectorcallfunc f = PyVectorcall_Function(func); + } 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 */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + if (max_char > 1114111) max_char = 1114111; + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; #endif - if (f) { - return f(func, args, (size_t)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, (size_t)nargs, NULL); - } + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; } - if (nargs == 0) { - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); - } - #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API - return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); - #else - return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); - #endif + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + for (i=0; i__pyx_empty_unicode, value_tuple); +bad: + Py_DECREF(value_tuple); + return result; +#endif } -/* 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); +/* 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) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + 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_DECREF(res); + return NULL; + } + Py_INCREF(src[i]); + } + return res; } - -/* TupleAndListFromArray */ -#if CYTHON_COMPILING_IN_CPYTHON +#elif CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { PyObject *v; Py_ssize_t i; @@ -102421,8 +89720,7 @@ __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res; if (n <= 0) { - Py_INCREF(__pyx_empty_tuple); - return __pyx_empty_tuple; + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); } res = PyTuple_New(n); if (unlikely(res == NULL)) return NULL; @@ -102443,9 +89741,10 @@ __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 +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { @@ -102490,57 +89789,41 @@ 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 +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL return PyObject_RichCompareBool(s1, s2, equals); #else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; -#endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); -#if PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); - } -#endif if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; + Py_ssize_t length, length2; int kind; void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; + #endif length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } @@ -102558,9 +89841,6 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { @@ -102570,9 +89850,6 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); @@ -102580,14 +89857,8 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int return result; } return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif return (equals == Py_EQ); return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif return (equals == Py_NE); #endif } @@ -102596,14 +89867,25 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int #if CYTHON_METH_FASTCALL static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) { - Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif for (i = 0; i < n; i++) { - if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; } for (i = 0; i < n; i++) { - int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ); if (unlikely(eq != 0)) { if (unlikely(eq < 0)) return NULL; return kwvalues[i]; @@ -102611,15 +89893,26 @@ static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyO } return NULL; } -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { - Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + Py_ssize_t i, nkwargs; PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif dict = PyDict_New(); if (unlikely(!dict)) return NULL; for (i=0; itype, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif +#if CYTHON_COMPILING_IN_PYPY +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + 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 { - num_expected = num_max; - more_or_less = "at most"; + assert(pvalue); + *pvalue = next; } - if (exact) { - more_or_less = "exactly"; + 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); } - PyErr_Format(PyExc_TypeError, - "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", - func_name, more_or_less, num_expected, - (num_expected == 1) ? "" : "s", num_found); + return result; } +#endif -/* RaiseDoubleKeywords */ +/* RaiseDoubleKeywords (used by ParseKeywordsImpl) */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION >= 3 "%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) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); + } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); + } +#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__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; + } +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + +/* ParseKeywordsImpl (used by ParseKeywords) */ +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; + } + name++; + } + return 0; +bad: + return -1; +} +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } #endif + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; } - -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +bad: + return -1; +} +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + 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 ( + #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) { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + break; + } + } + #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( + 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) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + name++; + } + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) + goto bad; + } else { + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordDictToDict( PyObject *kwds, - PyObject *const *kwvalues, - PyObject **argnames[], + PyObject ** const argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); - while (1) { - Py_XDECREF(key); key = NULL; - Py_XDECREF(value); value = NULL; - if (kwds_is_tuple) { - Py_ssize_t size; -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(kwds); -#else - size = PyTuple_Size(kwds); - if (size < 0) goto bad; -#endif - if (pos >= size) break; -#if CYTHON_AVOID_BORROWED_REFS - key = __Pyx_PySequence_ITEM(kwds, pos); - if (!key) goto bad; -#elif CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kwds, pos); -#else - key = PyTuple_GetItem(kwds, pos); - if (!key) goto bad; -#endif - value = kwvalues[pos]; - pos++; + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; } - else - { - if (!PyDict_Next(kwds, &pos, &key, &value)) break; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; } - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { +#else + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); + #endif + if (value == kwds2) { + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(value); - Py_DECREF(key); -#endif - key = NULL; - value = NULL; - continue; } -#if !CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); #endif - Py_INCREF(value); - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; + name++; + } + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + return 0; +bad: + return -1; +} +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) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { #if CYTHON_AVOID_BORROWED_REFS - value = NULL; + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); #endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = ( - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key) - ); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; #endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp == 1) { + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; } } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif } - Py_XDECREF(key); - Py_XDECREF(value); return 0; -arg_passed_twice: - __Pyx_RaiseDoubleKeywordsError(function_name, key); - goto bad; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - goto bad; invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); - #endif + goto bad; bad: + #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(key); - Py_XDECREF(value); + #endif return -1; } -/* ArgTypeTest */ +/* ParseKeywords */ +static 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) +{ + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* RaiseArgTupleInvalid */ +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) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* ArgTypeTestFunc (used by ArgTypeTest) */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { __Pyx_TypeName type_name; __Pyx_TypeName obj_type_name; + PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode; + int from_annotation_subclass = 0; if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } - else if (exact) { - #if PY_MAJOR_VERSION == 2 - if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; - #endif - } - else { + else if (!exact) { if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } else if (exact == 2) { + if (__Pyx_TypeCheck(obj, type)) { + from_annotation_subclass = 1; + extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately; + } } - type_name = __Pyx_PyType_GetName(type); - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME - ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + ", got " __Pyx_FMT_TYPENAME ")" +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + "%s%U" +#endif + , name, type_name, obj_type_name +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + , (from_annotation_subclass ? ". " : ""), extra_info +#endif + ); +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + if (exact == 2 && from_annotation_subclass) { + PyObject *res; + PyObject *vargs[2]; + vargs[0] = PyErr_GetRaisedException(); + vargs[1] = extra_info; + res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL); + Py_XDECREF(res); + PyErr_SetRaisedException(vargs[0]); + } +#endif __Pyx_DECREF_TypeName(type_name); __Pyx_DECREF_TypeName(obj_type_name); 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; @@ -102888,33 +90679,26 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#elif CYTHON_COMPILING_IN_LIMITED_API +#if CYTHON_COMPILING_IN_LIMITED_API if (unlikely(!__pyx_m)) { + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_NameError); return NULL; } result = PyObject_GetAttr(__pyx_m, name); if (likely(result)) { return result; } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + PyErr_Clear(); +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear(); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { - return __Pyx_NewRef(result); + return result; } -#endif #else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } @@ -102929,10 +90713,6 @@ static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_setattr)) - return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); -#endif return PyObject_SetAttr(obj, attr_name, value); } #endif @@ -102946,71 +90726,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_AVOID_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, PyInt_FromSsize_t(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_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, PyInt_FromSsize_t(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_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))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; + 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) { - PyObject *r, *key = PyInt_FromSsize_t(i); + 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)) { @@ -103029,7 +90815,9 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, return PySequence_GetItem(o, i); } #endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + (void)wraparound; + (void)boundscheck; + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); } /* ObjectGetItem */ @@ -103039,10 +90827,10 @@ 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_GetName(Py_TYPE(index)); + __Pyx_TypeName index_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(index)); PyErr_Clear(); PyErr_Format(PyExc_IndexError, "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); @@ -103053,7 +90841,7 @@ static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { __Pyx_TypeName obj_type_name; if (likely(PyType_Check(obj))) { - PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_n_s_class_getitem); + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_mstate_global->__pyx_n_u_class_getitem); if (!meth) { PyErr_Clear(); } else { @@ -103062,7 +90850,7 @@ static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { return result; } } - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); __Pyx_DECREF_TypeName(obj_type_name); @@ -103082,32 +90870,31 @@ static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { } #endif -/* GetAttr */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { -#if CYTHON_USE_TYPE_SLOTS -#if PY_MAJOR_VERSION >= 3 - if (likely(PyUnicode_Check(n))) -#else - if (likely(PyString_Check(n))) -#endif - return __Pyx_PyObject_GetAttrStr(o, n); -#endif - return PyObject_GetAttr(o, n); +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; } +#endif /* HasAttr */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; - if (unlikely(!__Pyx_PyBaseString_Check(n))) { + if (unlikely(!PyUnicode_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } - r = __Pyx_GetAttr(o, n); + r = __Pyx_PyObject_GetAttrStrNoError(o, n); if (!r) { - PyErr_Clear(); - return 0; + return (unlikely(PyErr_Occurred())) ? -1 : 0; } else { Py_DECREF(r); return 1; @@ -103116,25 +90903,20 @@ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { #endif /* DictGetItem */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (!PyErr_Occurred()) { - if (unlikely(PyTuple_Check(key))) { - PyObject* args = PyTuple_Pack(1, key); - if (likely(args)) { - PyErr_SetObject(PyExc_KeyError, args); - Py_DECREF(args); - } - } else { - PyErr_SetObject(PyExc_KeyError, key); + if (unlikely(__Pyx_PyDict_GetItemRef(d, key, &value) == 0)) { // no value, no error + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); } + } else { + PyErr_SetObject(PyExc_KeyError, key); } - return NULL; } - Py_INCREF(value); return value; } #endif @@ -103177,13 +90959,14 @@ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { return __Pyx_IterFinish(); } -/* PyObjectCall2Args */ -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); +/* 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 @@ -103206,18 +90989,12 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me Py_INCREF(descr); #if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) -#elif PY_MAJOR_VERSION >= 3 +#else #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) #endif -#else - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr))) - #endif #endif { meth_found = 1; @@ -103255,15 +91032,10 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me *method = descr; return 0; } - type_name = __Pyx_PyType_GetName(tp); + type_name = __Pyx_PyType_GetFullyQualifiedName(tp); PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", type_name, name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(name)); -#endif __Pyx_DECREF_TypeName(type_name); return 0; #else @@ -103283,55 +91055,16 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me *method = attr; return 0; } - -/* PyObjectCallMethod1 */ -#if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2) -static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { - PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); - Py_DECREF(method); - return result; -} -#endif -static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { -#if CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2 - 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); -#else - PyObject *method = NULL, *result; - int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); - if (likely(is_method)) { - result = __Pyx_PyObject_Call2Args(method, obj, arg); - Py_DECREF(method); - return result; - } - if (unlikely(!method)) return NULL; - return __Pyx__PyObject_CallMethod1(method, arg); -#endif -} - -/* StringJoin */ -static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { - (void) __Pyx_PyObject_CallMethod1; -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION < 3 - return _PyString_Join(sep, values); -#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 - return _PyBytes_Join(sep, values); -#else - return __Pyx_PyObject_CallMethod1(sep, __pyx_n_s_join, values); #endif -} - -/* PyObjectCallNoArg */ -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); -} -/* 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)) { @@ -103344,31 +91077,57 @@ 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(); - } else if (PyTuple_GET_SIZE(t) < index) { - __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); } else { - __Pyx_RaiseTooManyValuesError(index); + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return; + #endif + if (size < index) { + __Pyx_RaiseNeedMoreValuesError(size); + } else { + __Pyx_RaiseTooManyValuesError(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))) { + Py_ssize_t size; + if (has_known_size) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + size = __Pyx_PyTuple_GET_SIZE(tuple); + if (likely(size == 2)) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + if (size >= 0) { + __Pyx_UnpackTupleError(tuple, 2); + } + return -1; + } else { + return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple); + } +} static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { PyObject *value1 = NULL, *value2 = NULL; -#if CYTHON_COMPILING_IN_PYPY - value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; - value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + value1 = __Pyx_PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; + value2 = __Pyx_PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); @@ -103379,7 +91138,7 @@ static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( *pvalue1 = value1; *pvalue2 = value2; return 0; -#if CYTHON_COMPILING_IN_PYPY +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS bad: Py_XDECREF(value1); Py_XDECREF(value2); @@ -103415,7 +91174,7 @@ static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyOb } /* dict_iter */ -#if CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 +#if CYTHON_COMPILING_IN_PYPY #include #endif static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, @@ -103427,7 +91186,7 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_di *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; -#elif PY_MAJOR_VERSION >= 3 +#else static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { @@ -103462,53 +91221,93 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_di } return PyObject_GetIter(iterable); } -static CYTHON_INLINE int __Pyx_dict_iter_next( +#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, int source_is_dict) { - PyObject* next_item; -#if !CYTHON_COMPILING_IN_PYPY - if (source_is_dict) { - PyObject *key, *value; - if (unlikely(orig_length != PyDict_Size(iter_obj))) { - PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); + PyObject** pkey, PyObject** pvalue, PyObject** pitem) { + PyObject *key, *value; + if (unlikely(orig_length != PyDict_Size(iter_obj))) { + PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); + return -1; + } + if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { + return 0; + } + if (pitem) { + PyObject* tuple = PyTuple_New(2); + if (unlikely(!tuple)) { return -1; } - if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { - return 0; + Py_INCREF(key); + Py_INCREF(value); + #if CYTHON_ASSUME_SAFE_MACROS + PyTuple_SET_ITEM(tuple, 0, key); + PyTuple_SET_ITEM(tuple, 1, value); + #else + if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) { + Py_DECREF(value); + Py_DECREF(tuple); + return -1; } - if (pitem) { - PyObject* tuple = PyTuple_New(2); - if (unlikely(!tuple)) { - return -1; - } + if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) { + Py_DECREF(tuple); + return -1; + } + #endif + *pitem = tuple; + } else { + if (pkey) { Py_INCREF(key); + *pkey = key; + } + if (pvalue) { Py_INCREF(value); - PyTuple_SET_ITEM(tuple, 0, key); - PyTuple_SET_ITEM(tuple, 1, value); - *pitem = tuple; - } else { - if (pkey) { - Py_INCREF(key); - *pkey = key; - } - if (pvalue) { - Py_INCREF(value); - *pvalue = value; - } + *pvalue = value; } - return 1; + } + return 1; +} +#endif +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_AVOID_BORROWED_REFS + if (source_is_dict) { + int result; +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(iter_obj); +#endif + result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem); +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); +#endif + return result; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; - if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) return -1; + #endif + if (unlikely(pos >= tuple_size)) return 0; *ppos = pos + 1; + #if CYTHON_ASSUME_SAFE_MACROS next_item = PyTuple_GET_ITEM(iter_obj, pos); + #else + next_item = PyTuple_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #endif Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; - if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; + Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(list_size < 0)) return -1; + #endif + if (unlikely(pos >= list_size)) return 0; *ppos = pos + 1; - next_item = PyList_GET_ITEM(iter_obj, pos); - Py_INCREF(next_item); + next_item = __Pyx_PyList_GetItemRef(iter_obj, pos); + if (unlikely(!next_item)) return -1; } else #endif { @@ -103530,138 +91329,229 @@ static CYTHON_INLINE int __Pyx_dict_iter_next( return 1; } -/* PyIntBinop */ +/* PyLongBinop */ #if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { - CYTHON_MAYBE_UNUSED_VAR(intval); +static PyObject* __Pyx_Fallback___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, int inplace) { + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject* __Pyx_Unpacked___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { CYTHON_MAYBE_UNUSED_VAR(inplace); CYTHON_UNUSED_VAR(zerodivision_check); - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - const long b = intval; - long x; - long a = PyInt_AS_LONG(op1); - - x = (long)((unsigned long)a + (unsigned long)b); - if (likely((x^a) >= 0 || (x^b) >= 0)) - return PyInt_FromLong(x); - return PyLong_Type.tp_as_number->nb_add(op1, op2); - } - #endif - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(PyLong_CheckExact(op1))) { - const long b = intval; - long a, x; -#ifdef HAVE_LONG_LONG - const PY_LONG_LONG llb = intval; - PY_LONG_LONG lla, llx; -#endif - if (unlikely(__Pyx_PyLong_IsZero(op1))) { - return __Pyx_NewRef(op2); - } - if (likely(__Pyx_PyLong_IsCompact(op1))) { - a = __Pyx_PyLong_CompactValue(op1); - } 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 - } 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 - } - 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 - } - 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 - } - 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 - } - CYTHON_FALLTHROUGH; - default: return PyLong_Type.tp_as_number->nb_add(op1, op2); - } + const long b = intval; + long a; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla; + if (unlikely(__Pyx_PyLong_IsZero(op1))) { + return __Pyx_NewRef(op2); + } + 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 { + switch (size) { + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + 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])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } + 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])); + 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])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } + 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])); + 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])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } + break; } - x = a + b; + 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: - llx = lla + llb; + } + calculate_long_long: + { + PY_LONG_LONG llx; + llx = lla + llb; return PyLong_FromLongLong(llx); + } + +} #endif +static PyObject* __Pyx_Float___Pyx_PyLong_AddObjC(PyObject *float_val, long intval, int zerodivision_check) { + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + double a = __Pyx_PyFloat_AS_DOUBLE(float_val); + double result; - + result = ((double)a) + (double)b; + return PyFloat_FromDouble(result); +} +static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(zerodivision_check); + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + return __Pyx_Unpacked___Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check); } #endif if (PyFloat_CheckExact(op1)) { - const long b = intval; -#if CYTHON_COMPILING_IN_LIMITED_API - double a = __pyx_PyFloat_AsDouble(op1); -#else - double a = PyFloat_AS_DOUBLE(op1); + return __Pyx_Float___Pyx_PyLong_AddObjC(op1, intval, zerodivision_check); + } + return __Pyx_Fallback___Pyx_PyLong_AddObjC(op1, op2, inplace); +} +#endif + +/* PyObjectVectorCallKwBuilder */ +#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); + args[n] = value; + return 0; +} +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return PyDict_SetItem(builder, key, value); +} +#endif + +/* 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 + 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 - double result; - - PyFPE_START_PROTECT("add", return NULL) - result = ((double)a) + (double)b; - PyFPE_END_PROTECT(result) - return PyFloat_FromDouble(result); + 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; } - return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); + 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_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; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + Py_ssize_t remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + 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 (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 = (Py_ssize_t) (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 = (Py_ssize_t) (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 = (Py_ssize_t) (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); +} /* SliceTupleAndList */ #if CYTHON_COMPILING_IN_CPYTHON @@ -103680,7 +91570,13 @@ static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop *_start = start; *_stop = stop; } -static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice( +static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice( + PyObject* src, Py_ssize_t start, Py_ssize_t stop) { + Py_ssize_t length = PyTuple_GET_SIZE(src); + __Pyx_crop_slice(&start, &stop, &length); + return __Pyx_PyTuple_FromArray(((PyTupleObject*)src)->ob_item + start, length); +} +static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice_locked( PyObject* src, Py_ssize_t start, Py_ssize_t stop) { Py_ssize_t length = PyList_GET_SIZE(src); __Pyx_crop_slice(&start, &stop, &length); @@ -103689,204 +91585,84 @@ static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice( } return __Pyx_PyList_FromArray(((PyListObject*)src)->ob_item + start, length); } -static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice( +static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice( PyObject* src, Py_ssize_t start, Py_ssize_t stop) { - Py_ssize_t length = PyTuple_GET_SIZE(src); - __Pyx_crop_slice(&start, &stop, &length); - return __Pyx_PyTuple_FromArray(((PyTupleObject*)src)->ob_item + start, length); -} -#endif - -/* UnpackUnboundCMethod */ -static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { PyObject *result; - PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); - if (unlikely(!selfless_args)) return NULL; - result = PyObject_Call(method, selfless_args, kwargs); - Py_DECREF(selfless_args); + __Pyx_BEGIN_CRITICAL_SECTION(src); + result = __Pyx_PyList_GetSlice_locked(src, start, stop); + __Pyx_END_CRITICAL_SECTION(); return result; } -static PyMethodDef __Pyx_UnboundCMethod_Def = { - "CythonUnboundCMethod", - __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), - METH_VARARGS | METH_KEYWORDS, - NULL -}; -static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { - PyObject *method; - method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); - if (unlikely(!method)) - return -1; - target->method = method; -#if CYTHON_COMPILING_IN_CPYTHON - #if PY_MAJOR_VERSION >= 3 - if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) - #else - if (likely(!__Pyx_CyOrPyCFunction_Check(method))) - #endif - { - PyMethodDescrObject *descr = (PyMethodDescrObject*) method; - target->func = descr->d_method->ml_meth; - target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); - } else -#endif -#if CYTHON_COMPILING_IN_PYPY -#else - if (PyCFunction_Check(method)) -#endif - { - PyObject *self; - int self_found; -#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY - self = PyObject_GetAttrString(method, "__self__"); - if (!self) { - PyErr_Clear(); - } -#else - self = PyCFunction_GET_SELF(method); -#endif - self_found = (self && self != Py_None); -#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY - Py_XDECREF(self); -#endif - if (self_found) { - PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); - if (unlikely(!unbound_method)) return -1; - Py_DECREF(method); - target->method = unbound_method; - } - } - return 0; -} +#endif // CYTHON_COMPILING_IN_CPYTHON -/* CallUnboundCMethod0 */ -static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { - PyObject *args, *result = NULL; - if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; -#if CYTHON_ASSUME_SAFE_MACROS - args = PyTuple_New(1); - if (unlikely(!args)) goto bad; - Py_INCREF(self); - PyTuple_SET_ITEM(args, 0, self); -#else - args = PyTuple_Pack(1, self); - if (unlikely(!args)) goto bad; -#endif - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); - Py_DECREF(args); -bad: +/* 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); +} +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; } /* py_dict_keys */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d) { - if (PY_MAJOR_VERSION >= 3) - return __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyDict_Type_keys, d); - else - return PyDict_Keys(d); + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_keys, d); } -/* PyNumberPow2 */ -static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace) { -#if !CYTHON_COMPILING_IN_PYPY - Py_ssize_t shiftby; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(exp))) { - shiftby = PyInt_AS_LONG(exp); - } else -#endif - if (likely(PyLong_CheckExact(exp))) { - #if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsZero(exp)) { - return PyInt_FromLong(1L); - } else if (__Pyx_PyLong_IsNeg(exp)) { - goto fallback; - } else if (__Pyx_PyLong_IsCompact(exp)) { - shiftby = __Pyx_PyLong_CompactValueUnsigned(exp); - } else { - shiftby = PyLong_AsSsize_t(exp); - } - #else - shiftby = PyLong_AsSsize_t(exp); - #endif +/* 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)); + if (argname) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got " __Pyx_FMT_TYPENAME ")", + argname, type_name, obj_type_name + ); } else { - goto fallback; + PyErr_Format(PyExc_TypeError, + "Expected %.200s, got " __Pyx_FMT_TYPENAME, + type_name, obj_type_name + ); } - if (likely(shiftby >= 0)) { - if ((size_t)shiftby <= sizeof(long) * 8 - 2) { - long value = 1L << shiftby; - return PyInt_FromLong(value); -#ifdef HAVE_LONG_LONG - } else if ((size_t)shiftby <= sizeof(unsigned PY_LONG_LONG) * 8 - 1) { - unsigned PY_LONG_LONG value = ((unsigned PY_LONG_LONG)1) << shiftby; - return PyLong_FromUnsignedLongLong(value); -#endif - } else { - PyObject *result, *one = PyInt_FromLong(1L); - if (unlikely(!one)) return NULL; - result = PyNumber_Lshift(one, exp); - Py_DECREF(one); - return result; - } - } else if (shiftby == -1 && PyErr_Occurred()) { - PyErr_Clear(); + __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; } -fallback: -#endif - return (inplace ? PyNumber_InPlacePower : PyNumber_Power)(two, exp, none); + 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 */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, - int has_cstart, int has_cstop, int wraparound) { + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { __Pyx_TypeName obj_type_name; #if CYTHON_USE_TYPE_SLOTS - PyMappingMethods* mp; -#if PY_MAJOR_VERSION < 3 - PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; - if (likely(ms && ms->sq_slice)) { - if (!has_cstart) { - if (_py_start && (*_py_start != Py_None)) { - cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); - if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; - } else - cstart = 0; - } - if (!has_cstop) { - if (_py_stop && (*_py_stop != Py_None)) { - cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); - if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; - } else - cstop = PY_SSIZE_T_MAX; - } - if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { - Py_ssize_t l = ms->sq_length(obj); - if (likely(l >= 0)) { - if (cstop < 0) { - cstop += l; - if (cstop < 0) cstop = 0; - } - if (cstart < 0) { - cstart += l; - if (cstart < 0) cstart = 0; - } - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - goto bad; - PyErr_Clear(); - } - } - return ms->sq_slice(obj, cstart, cstop); - } -#else - CYTHON_UNUSED_VAR(wraparound); -#endif - mp = Py_TYPE(obj)->tp_as_mapping; + PyMappingMethods* mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_subscript)) -#else - CYTHON_UNUSED_VAR(wraparound); #endif { PyObject* result; @@ -103900,7 +91676,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, py_start = *_py_start; } else { if (has_cstart) { - owned_start = py_start = PyInt_FromSsize_t(cstart); + owned_start = py_start = PyLong_FromSsize_t(cstart); if (unlikely(!py_start)) goto bad; } else py_start = Py_None; @@ -103909,7 +91685,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, py_stop = *_py_stop; } else { if (has_cstop) { - owned_stop = py_stop = PyInt_FromSsize_t(cstop); + owned_stop = py_stop = PyLong_FromSsize_t(cstop); if (unlikely(!py_stop)) { Py_XDECREF(owned_start); goto bad; @@ -103932,7 +91708,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, } return result; } - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "'" __Pyx_FMT_TYPENAME "' object is unsliceable", obj_type_name); __Pyx_DECREF_TypeName(obj_type_name); @@ -103940,198 +91716,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, return NULL; } -/* PyIntBinop */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_RemainderObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { - CYTHON_MAYBE_UNUSED_VAR(intval); - CYTHON_MAYBE_UNUSED_VAR(inplace); - CYTHON_UNUSED_VAR(zerodivision_check); - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - const long b = intval; - long x; - long a = PyInt_AS_LONG(op1); - - x = a % b; - x += ((x != 0) & ((x ^ b) < 0)) * b; - return PyInt_FromLong(x); - } - #endif - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(PyLong_CheckExact(op1))) { - const long b = intval; - long a, x; -#ifdef HAVE_LONG_LONG - const PY_LONG_LONG llb = intval; - PY_LONG_LONG lla, llx; -#endif - if (unlikely(__Pyx_PyLong_IsZero(op1))) { - return __Pyx_NewRef(op1); - } - if (likely(__Pyx_PyLong_IsCompact(op1))) { - a = __Pyx_PyLong_CompactValue(op1); - } 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 - } 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 - } - 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 - } - 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 - } - 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 - } - CYTHON_FALLTHROUGH; - default: return PyLong_Type.tp_as_number->nb_remainder(op1, op2); - } - } - x = a % b; - x += ((x != 0) & ((x ^ b) < 0)) * b; - return PyLong_FromLong(x); -#ifdef HAVE_LONG_LONG - long_long: - llx = lla % llb; - llx += ((llx != 0) & ((llx ^ llb) < 0)) * llb; - return PyLong_FromLongLong(llx); -#endif - - - } - #endif - return (inplace ? PyNumber_InPlaceRemainder : PyNumber_Remainder)(op1, op2); -} -#endif - -/* PyIntCompare */ -static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace) { - CYTHON_MAYBE_UNUSED_VAR(intval); - CYTHON_UNUSED_VAR(inplace); - if (op1 == op2) { - return 1; - } - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - const long b = intval; - long a = PyInt_AS_LONG(op1); - return (a == b); - } - #endif - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(PyLong_CheckExact(op1))) { - int unequal; - unsigned long uintval; - Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); - const digit* digits = __Pyx_PyLong_Digits(op1); - if (intval == 0) { - return (__Pyx_PyLong_IsZero(op1) == 1); - } else if (intval < 0) { - if (__Pyx_PyLong_IsNonNeg(op1)) - return 0; - intval = -intval; - } else { - if (__Pyx_PyLong_IsNeg(op1)) - return 0; - } - uintval = (unsigned long) intval; -#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 4)) { - unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else -#endif -#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 3)) { - unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else -#endif -#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 2)) { - unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else -#endif -#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 1)) { - unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else -#endif - unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); - return (unequal == 0); - } - #endif - if (PyFloat_CheckExact(op1)) { - const long b = intval; -#if CYTHON_COMPILING_IN_LIMITED_API - double a = __pyx_PyFloat_AsDouble(op1); -#else - double a = PyFloat_AS_DOUBLE(op1); -#endif - return ((double)a == (double)b); - } - return __Pyx_PyObject_IsTrueAndDecref( - PyObject_RichCompare(op1, op2, Py_EQ)); -} - /* SetItemInt */ static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { int r; @@ -104141,29 +91725,37 @@ 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_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)))) { - PyObject* old = PyList_GET_ITEM(o, n); + if ((CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS && !__Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared))) { Py_INCREF(v); + 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); - 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 = PyInt_FromSsize_t(i); + PyObject *key = PyLong_FromSsize_t(i); if (unlikely(!key)) return -1; r = mm->mp_ass_subscript(o, key, v); 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)) { @@ -104178,25 +91770,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 - return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); + (void)wraparound; + (void)boundscheck; + return __Pyx_SetItemInt_Generic(o, PyLong_FromSsize_t(i), v); } /* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType_3_0_10 -#define __PYX_HAVE_RT_ImportType_3_0_10 -static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, - size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) +#ifndef __PYX_HAVE_RT_ImportType_3_2_4 +#define __PYX_HAVE_RT_ImportType_3_2_4 +static PyTypeObject *__Pyx_ImportType_3_2_4(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_4 check_size) { PyObject *result = 0; - char warning[200]; 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 @@ -104209,10 +91801,13 @@ static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *modul 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 + if (size == 0) { + return (PyTypeObject *)result; + } py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; @@ -104244,7 +91839,7 @@ static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *modul module_name, class_name, size, basicsize+itemsize); goto bad; } - if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 && + if (check_size == __Pyx_ImportType_CheckSize_Error_3_2_4 && ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " @@ -104252,12 +91847,13 @@ static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *modul module_name, class_name, size, basicsize, basicsize+itemsize); goto bad; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_2_4 && (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", + module_name, class_name, size, basicsize) < 0) { + goto bad; + } } return (PyTypeObject *)result; bad: @@ -104266,25 +91862,101 @@ static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *modul } #endif -/* FixUpExtensionType */ -#if CYTHON_USE_TYPE_SPECS +/* 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); @@ -104301,18 +91973,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); @@ -104320,40 +91985,152 @@ 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; } + +/* 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 */ +/* FetchSharedCythonModule (used by FetchCommonType) */ static PyObject *__Pyx_FetchSharedCythonABIModule(void) { - return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); } -/* FetchCommonType */ +/* 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 + result->ob_type = metaclass; +#endif + Py_DECREF(old_tp); + } + return result; +} +#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 basicsize, Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; if (!PyType_Check(cached_type)) { PyErr_Format(PyExc_TypeError, "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__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; +#else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; +#endif if (basicsize != expected_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", @@ -104362,80 +92139,53 @@ static int __Pyx_VerifyCachedType(PyObject *cached_type, } return 0; } -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* abi_module; - const char* object_name; - PyTypeObject *cached_type = NULL; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - object_name = strrchr(type->tp_name, '.'); - object_name = object_name ? object_name+1 : type->tp_name; - cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - if (__Pyx_VerifyCachedType( - (PyObject *)cached_type, - object_name, - cached_type->tp_basicsize, - type->tp_basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) - goto bad; - Py_INCREF(type); - cached_type = type; -done: - Py_DECREF(abi_module); - return cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#else -static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { - PyObject *abi_module, *cached_type = NULL; +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, '.'); object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - cached_type = PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - Py_ssize_t basicsize; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *py_basicsize; - py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); - if (unlikely(!py_basicsize)) goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; -#else - basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; -#endif + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { if (__Pyx_VerifyCachedType( cached_type, object_name, - basicsize, spec->basicsize) < 0) { goto bad; } goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - 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; - if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; + 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); + cached_type = new_cached_type; + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); + } done: - Py_DECREF(abi_module); + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); assert(cached_type == NULL || PyType_Check(cached_type)); return (PyTypeObject *) cached_type; bad: @@ -104443,21 +92193,125 @@ static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec cached_type = NULL; goto done; } + +/* 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; +} -/* PyVectorcallFastCallDict */ -#if CYTHON_METH_FASTCALL +/* 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) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif + +/* PyMethodNew (used by CythonFunctionShared) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); + } + #else + result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); + #endif + return result; +} +#else +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#endif + +/* 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; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); if (unlikely(newargs == NULL)) { PyErr_NoMemory(); @@ -104470,13 +92324,21 @@ 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)) { - keys_are_strings &= Py_TYPE(key)->tp_flags; - Py_INCREF(key); - Py_INCREF(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 + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else PyTuple_SET_ITEM(kwnames, i, key); + #endif kwvalues[i] = value; i++; } @@ -104486,6 +92348,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]); @@ -104494,16 +92359,29 @@ static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vector } static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { - if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : +#if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); +#else + PyDict_GET_SIZE(kw); +#endif + if (kw_size == 0) { return vc(func, args, nargs, NULL); } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } +#endif return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #endif -/* CythonFunctionShared */ +/* CythonFunctionShared (used by CythonFunction) */ #if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { if (__Pyx_CyFunction_Check(func)) { return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; } else if (PyCFunction_Check(func)) { @@ -104511,8 +92389,25 @@ static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) } return 0; } +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} #else -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; } #endif @@ -104528,20 +92423,15 @@ static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* #endif } static PyObject * -__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) +__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) { - CYTHON_UNUSED_VAR(closure); if (unlikely(op->func_doc == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); if (unlikely(!op->func_doc)) return NULL; #else if (((PyCFunctionObject*)op)->m_ml->ml_doc) { -#if PY_MAJOR_VERSION >= 3 op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#else - op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#endif if (unlikely(op->func_doc == NULL)) return NULL; } else { @@ -104553,6 +92443,15 @@ __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) Py_INCREF(op->func_doc); return op->func_doc; } +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) { @@ -104561,20 +92460,19 @@ __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *cont value = Py_None; } Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * -__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) { - CYTHON_UNUSED_VAR(context); if (unlikely(op->func_name == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_name = PyObject_GetAttrString(op->func, "__name__"); -#elif PY_MAJOR_VERSION >= 3 - op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #else - op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #endif if (unlikely(op->func_name == NULL)) return NULL; @@ -104582,49 +92480,58 @@ __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) Py_INCREF(op->func_name); return op->func_name; } +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} static int __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { + if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); Py_INCREF(op->func_qualname); - return op->func_qualname; + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { + if (unlikely(value == NULL || !PyUnicode_Check(value))) { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); return 0; } +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 static PyObject * __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) { @@ -104637,24 +92544,7 @@ __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) Py_INCREF(op->func_dict); return op->func_dict; } -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_Py_XDECREF_SET(op->func_dict, value); - return 0; -} +#endif static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) { @@ -104713,13 +92603,14 @@ __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * -__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { +__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { PyObject* result = op->defaults_tuple; - CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; @@ -104731,6 +92622,15 @@ __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { Py_INCREF(result); return result; } +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} static int __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); @@ -104744,13 +92644,14 @@ __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, voi PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * -__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { +__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { PyObject* result = op->defaults_kwdict; - CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; @@ -104762,6 +92663,15 @@ __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { Py_INCREF(result); return result; } +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} static int __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); @@ -104773,13 +92683,14 @@ __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, vo return -1; } Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); return 0; } static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { +__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { PyObject* result = op->func_annotations; - CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; @@ -104789,16 +92700,19 @@ __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { return result; } static PyObject * -__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { - int is_coroutine; +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; CYTHON_UNUSED_VAR(context); - if (op->func_is_coroutine) { - return __Pyx_NewRef(op->func_is_coroutine); - } - is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; -#if PY_VERSION_HEX >= 0x03050000 + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; if (is_coroutine) { - PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; fromlist = PyList_New(1); if (unlikely(!fromlist)) return NULL; Py_INCREF(marker); @@ -104811,20 +92725,68 @@ __Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { return NULL; } #endif - module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); Py_DECREF(fromlist); if (unlikely(!module)) goto ignore; - op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); Py_DECREF(module); - if (likely(op->func_is_coroutine)) { - return __Pyx_NewRef(op->func_is_coroutine); + if (likely(is_coroutine_value)) { + return is_coroutine_value; } ignore: PyErr_Clear(); } + return __Pyx_PyBool_FromLong(is_coroutine); +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); + } + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); +#endif +} +static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); #endif - op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); - return __Pyx_NewRef(op->func_is_coroutine); } #if CYTHON_COMPILING_IN_LIMITED_API static PyObject * @@ -104839,24 +92801,29 @@ __Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *c } #endif static PyGetSetDef __pyx_CyFunction_getsets[] = { - {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, - {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, - {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, - {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"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}, +#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}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__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}, + {"_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}, #endif @@ -104864,23 +92831,21 @@ static PyGetSetDef __pyx_CyFunction_getsets[] = { }; static PyMemberDef __pyx_CyFunction_members[] = { #if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, + {"__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_USE_TYPE_SPECS - {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, #if CYTHON_METH_FASTCALL -#if CYTHON_BACKPORT_VECTORCALL - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, #else -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, -#endif + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, #else - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #endif #endif {0, 0, 0, 0, 0} @@ -104888,19 +92853,19 @@ static PyMemberDef __pyx_CyFunction_members[] = { static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) { + PyObject *result = NULL; CYTHON_UNUSED_VAR(args); -#if PY_MAJOR_VERSION >= 3 + __Pyx_BEGIN_CRITICAL_SECTION(m); Py_INCREF(m->func_qualname); - return m->func_qualname; -#else - return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); -#endif + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; } static PyMethodDef __pyx_CyFunction_methods[] = { {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, {0, 0, 0, 0} }; -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) @@ -104928,7 +92893,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; @@ -104942,8 +92909,6 @@ static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef * Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; - op->defaults_pyobjects = 0; - op->defaults_size = 0; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; @@ -104984,7 +92949,13 @@ __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); @@ -105005,14 +92976,7 @@ __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); Py_CLEAR(m->func_is_coroutine); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_XDECREF(pydefaults[i]); - PyObject_Free(m->defaults); - m->defaults = NULL; - } + Py_CLEAR(m->defaults); return 0; } static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) @@ -105029,47 +92993,57 @@ static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) } static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) { + { + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; + } Py_VISIT(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func); #else Py_VISIT(((PyCFunctionObject*)m)->m_module); #endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func_dict); - Py_VISIT(m->func_name); - Py_VISIT(m->func_qualname); +#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); - Py_VISIT(m->func_code); + __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_is_coroutine); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_VISIT(pydefaults[i]); - } + Py_VISIT(m->defaults); return 0; } static PyObject* __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) { -#if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromFormat("", + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", op->func_qualname, (void *)op); -#else - return PyString_FromFormat("", - PyString_AsString(op->func_qualname), (void *)op); -#endif + __Pyx_END_CRITICAL_SECTION(); + return repr; } static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *f = ((__pyx_CyFunctionObject*)func)->func; - PyObject *py_name = NULL; PyCFunction meth; int flags; meth = PyCFunction_GetFunction(f); @@ -105088,10 +93062,10 @@ static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, Py return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: - return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS +#if CYTHON_ASSUME_SAFE_SIZE size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); @@ -105099,24 +93073,15 @@ static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, Py #endif if (likely(size == 0)) return (*meth)(self, NULL); -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS +#if CYTHON_ASSUME_SAFE_SIZE size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); @@ -105135,18 +93100,9 @@ static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, Py #endif return result; } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); return NULL; } break; @@ -105154,16 +93110,8 @@ static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, Py PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); return NULL; } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", - py_name); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", - f->m_ml->ml_name); -#endif + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { @@ -105180,10 +93128,10 @@ 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 +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); if (vc) { -#if CYTHON_ASSUME_SAFE_MACROS +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); #else (void) &__Pyx_PyVectorcall_FastCallDict; @@ -105195,11 +93143,11 @@ static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, P Py_ssize_t argc; PyObject *new_args; PyObject *self; -#if CYTHON_ASSUME_SAFE_MACROS +#if CYTHON_ASSUME_SAFE_SIZE argc = PyTuple_GET_SIZE(args); #else argc = PyTuple_Size(args); - if (unlikely(!argc) < 0) return NULL; + if (unlikely(argc < 0)) return NULL; #endif new_args = PyTuple_GetSlice(args, 1, argc); if (unlikely(!new_args)) @@ -105207,14 +93155,9 @@ static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, P self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); -#if PY_MAJOR_VERSION > 2 PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); -#else - PyErr_SetString(PyExc_TypeError, - "unbound method needs an argument"); -#endif return NULL; } result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); @@ -105224,21 +93167,21 @@ static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, P } return result; } -#if CYTHON_METH_FASTCALL +#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; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { if (unlikely(nargs < 1)) { - PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", - ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); return -1; } ret = 1; } - if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); return -1; } return ret; @@ -105246,13 +93189,14 @@ 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; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#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); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { case 1: self = args[0]; @@ -105260,29 +93204,34 @@ static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *c nargs -= 1; break; case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif break; default: return NULL; } if (unlikely(nargs != 0)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); return NULL; } - return def->ml_meth(self, NULL); + return meth(self, NULL); } static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#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); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { case 1: self = args[0]; @@ -105290,29 +93239,34 @@ static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const nargs -= 1; break; case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif break; default: return NULL; } if (unlikely(nargs != 1)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); return NULL; } - return def->ml_meth(self, args[0]); + return meth(self, args[0]); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#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); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { case 1: self = args[0]; @@ -105320,24 +93274,30 @@ static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, nargs -= 1; break; case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif break; default: return NULL; } - return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; 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); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { case 1: self = args[0]; @@ -105345,15 +93305,24 @@ static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject nargs -= 1; break; case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif break; default: return NULL; } - return ((__Pyx_PyCMethod)(void(*)(void))def->ml_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 -#if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_CyFunctionType_slots[] = { {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, @@ -105373,118 +93342,34 @@ static PyType_Spec __pyx_CyFunctionType_spec = { #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif -#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) +#if CYTHON_METH_FASTCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) _Py_TPFLAGS_HAVE_VECTORCALL | #endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - __pyx_CyFunctionType_slots -}; -#else -static PyTypeObject __pyx_CyFunctionType_type = { - PyVarObject_HEAD_INIT(0, 0) - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, - (destructor) __Pyx_CyFunction_dealloc, -#if !CYTHON_METH_FASTCALL - 0, -#elif CYTHON_BACKPORT_VECTORCALL - (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), -#else - offsetof(PyCFunctionObject, vectorcall), -#endif - 0, - 0, -#if PY_MAJOR_VERSION < 3 - 0, -#else - 0, -#endif - (reprfunc) __Pyx_CyFunction_repr, - 0, - 0, - 0, - 0, - __Pyx_CyFunction_CallAsMethod, - 0, - 0, - 0, - 0, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL - _Py_TPFLAGS_HAVE_VECTORCALL | +#endif // CYTHON_METH_FASTCALL +#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, - 0, - (traverseproc) __Pyx_CyFunction_traverse, - (inquiry) __Pyx_CyFunction_clear, - 0, -#if PY_VERSION_HEX < 0x030500A0 - offsetof(__pyx_CyFunctionObject, func_weakreflist), -#else - offsetof(PyCFunctionObject, m_weakreflist), -#endif - 0, - 0, - __pyx_CyFunction_methods, - __pyx_CyFunction_members, - __pyx_CyFunction_getsets, - 0, - 0, - __Pyx_PyMethod_New, - 0, - offsetof(__pyx_CyFunctionObject, func_dict), - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -#if PY_VERSION_HEX >= 0x030400a1 - 0, -#endif -#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, -#endif -#if __PYX_NEED_TP_PRINT_SLOT - 0, -#endif -#if PY_VERSION_HEX >= 0x030C0000 - 0, -#endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, -#endif + __pyx_CyFunctionType_slots }; -#endif static int __pyx_CyFunction_init(PyObject *module) { -#if CYTHON_USE_TYPE_SPECS - __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); -#else - CYTHON_UNUSED_VAR(module); - __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); -#endif - if (unlikely(__pyx_CyFunctionType == NULL)) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { return -1; } return 0; } -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults = PyObject_Malloc(size); + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); if (unlikely(!m->defaults)) - return PyErr_NoMemory(); - memset(m->defaults, 0, size); - m->defaults_pyobjects = pyobjects; - m->defaults_size = size; + return NULL; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { @@ -105507,7 +93392,7 @@ static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, Py static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { PyObject *op = __Pyx_CyFunction_Init( - PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType), ml, flags, qualname, closure, module, globals, code ); if (likely(op)) { @@ -105521,10 +93406,26 @@ static PyObject* __Pyx_PEP560_update_bases(PyObject *bases) { Py_ssize_t i, j, size_bases; - PyObject *base, *meth, *new_base, *result, *new_bases = NULL; + PyObject *base = NULL, *meth, *new_base, *result, *new_bases = NULL; +#if CYTHON_ASSUME_SAFE_SIZE size_bases = PyTuple_GET_SIZE(bases); +#else + size_bases = PyTuple_Size(bases); + if (size_bases < 0) return NULL; +#endif for (i = 0; i < size_bases; i++) { - base = PyTuple_GET_ITEM(bases, i); +#if CYTHON_AVOID_BORROWED_REFS + Py_CLEAR(base); +#endif +#if CYTHON_ASSUME_SAFE_MACROS + base = PyTuple_GET_ITEM(bases, i); +#else + base = PyTuple_GetItem(bases, i); + if (!base) goto error; +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(base); +#endif if (PyType_Check(base)) { if (new_bases) { if (PyList_Append(new_bases, base) < 0) { @@ -105533,7 +93434,7 @@ __Pyx_PEP560_update_bases(PyObject *bases) } continue; } - meth = __Pyx_PyObject_GetAttrStrNoError(base, __pyx_n_s_mro_entries); + meth = __Pyx_PyObject_GetAttrStrNoError(base, __pyx_mstate_global->__pyx_n_u_mro_entries); if (!meth && PyErr_Occurred()) { goto error; } @@ -105561,12 +93462,25 @@ __Pyx_PEP560_update_bases(PyObject *bases) goto error; } for (j = 0; j < i; j++) { - base = PyTuple_GET_ITEM(bases, j); - PyList_SET_ITEM(new_bases, j, base); - Py_INCREF(base); + PyObject *base_from_list; +#if CYTHON_ASSUME_SAFE_MACROS + base_from_list = PyTuple_GET_ITEM(bases, j); + PyList_SET_ITEM(new_bases, j, base_from_list); + Py_INCREF(base_from_list); +#else + base_from_list = PyTuple_GetItem(bases, j); + if (!base_from_list) goto error; + Py_INCREF(base_from_list); + if (PyList_SetItem(new_bases, j, base_from_list) < 0) goto error; +#endif } } +#if CYTHON_ASSUME_SAFE_SIZE j = PyList_GET_SIZE(new_bases); +#else + j = PyList_Size(new_bases); + if (j < 0) goto error; +#endif if (PyList_SetSlice(new_bases, j, j, new_base) < 0) { goto error; } @@ -105578,16 +93492,22 @@ __Pyx_PEP560_update_bases(PyObject *bases) } result = PyList_AsTuple(new_bases); Py_DECREF(new_bases); +#if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(base); +#endif return result; error: Py_XDECREF(new_bases); +#if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(base); +#endif return NULL; } /* CalculateMetaclass */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { Py_ssize_t i, nbases; -#if CYTHON_ASSUME_SAFE_MACROS +#if CYTHON_ASSUME_SAFE_SIZE nbases = PyTuple_GET_SIZE(bases); #else nbases = PyTuple_Size(bases); @@ -105602,10 +93522,6 @@ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bas if (!tmp) return NULL; #endif tmptype = Py_TYPE(tmp); -#if PY_MAJOR_VERSION < 3 - if (tmptype == &PyClass_Type) - continue; -#endif if (!metaclass) { metaclass = tmptype; continue; @@ -105624,25 +93540,23 @@ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bas return NULL; } if (!metaclass) { -#if PY_MAJOR_VERSION < 3 - metaclass = &PyClass_Type; -#else metaclass = &PyType_Type; -#endif } Py_INCREF((PyObject*) metaclass); return (PyObject*) metaclass; } -/* PyObjectLookupSpecial */ +/* 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 (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; PyTypeObject *tp = Py_TYPE(obj); -#if PY_MAJOR_VERSION < 3 - if (unlikely(PyInstance_Check(obj))) - return with_error ? __Pyx_PyObject_GetAttrStr(obj, attr_name) : __Pyx_PyObject_GetAttrStrNoError(obj, attr_name); -#endif res = _PyType_Lookup(tp, attr_name); if (likely(res)) { descrgetfunc f = Py_TYPE(res)->tp_descr_get; @@ -105663,7 +93577,7 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { PyObject *ns; if (metaclass) { - PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_n_s_prepare); + PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_mstate_global->__pyx_n_u_prepare); if (prep) { PyObject *pargs[3] = {NULL, name, bases}; ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); @@ -105678,148 +93592,14 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, } if (unlikely(!ns)) return NULL; - if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; -#if PY_VERSION_HEX >= 0x03030000 - if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; -#else - CYTHON_MAYBE_UNUSED_VAR(qualname); -#endif - if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_doc, doc) < 0)) goto bad; return ns; bad: Py_DECREF(ns); return NULL; } -#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS -static int __Pyx_SetNamesPEP487(PyObject *type_obj) { - PyTypeObject *type = (PyTypeObject*) type_obj; - PyObject *names_to_set, *key, *value, *set_name, *tmp; - Py_ssize_t i = 0; -#if CYTHON_USE_TYPE_SLOTS - names_to_set = PyDict_Copy(type->tp_dict); -#else - { - PyObject *d = PyObject_GetAttr(type_obj, __pyx_n_s_dict); - names_to_set = NULL; - if (likely(d)) { - PyObject *names_to_set = PyDict_New(); - int ret = likely(names_to_set) ? PyDict_Update(names_to_set, d) : -1; - Py_DECREF(d); - if (unlikely(ret < 0)) - Py_CLEAR(names_to_set); - } - } -#endif - if (unlikely(names_to_set == NULL)) - goto bad; - while (PyDict_Next(names_to_set, &i, &key, &value)) { - set_name = __Pyx_PyObject_LookupSpecialNoError(value, __pyx_n_s_set_name); - if (unlikely(set_name != NULL)) { - tmp = __Pyx_PyObject_Call2Args(set_name, type_obj, key); - Py_DECREF(set_name); - if (unlikely(tmp == NULL)) { - __Pyx_TypeName value_type_name = - __Pyx_PyType_GetName(Py_TYPE(value)); - __Pyx_TypeName type_name = __Pyx_PyType_GetName(type); - PyErr_Format(PyExc_RuntimeError, -#if PY_MAJOR_VERSION >= 3 - "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %R " "in '" __Pyx_FMT_TYPENAME "'", - value_type_name, key, type_name); -#else - "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %.100s in '" __Pyx_FMT_TYPENAME "'", - value_type_name, - PyString_Check(key) ? PyString_AS_STRING(key) : "?", - type_name); -#endif - goto bad; - } else { - Py_DECREF(tmp); - } - } - else if (unlikely(PyErr_Occurred())) { - goto bad; - } - } - Py_DECREF(names_to_set); - return 0; -bad: - Py_XDECREF(names_to_set); - return -1; -} -static PyObject *__Pyx_InitSubclassPEP487(PyObject *type_obj, PyObject *mkw) { -#if CYTHON_USE_TYPE_SLOTS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - PyTypeObject *type = (PyTypeObject*) type_obj; - PyObject *mro = type->tp_mro; - Py_ssize_t i, nbases; - if (unlikely(!mro)) goto done; - (void) &__Pyx_GetBuiltinName; - Py_INCREF(mro); - nbases = PyTuple_GET_SIZE(mro); - assert(PyTuple_GET_ITEM(mro, 0) == type_obj); - for (i = 1; i < nbases-1; i++) { - PyObject *base, *dict, *meth; - base = PyTuple_GET_ITEM(mro, i); - dict = ((PyTypeObject *)base)->tp_dict; - meth = __Pyx_PyDict_GetItemStrWithError(dict, __pyx_n_s_init_subclass); - if (unlikely(meth)) { - descrgetfunc f = Py_TYPE(meth)->tp_descr_get; - PyObject *res; - Py_INCREF(meth); - if (likely(f)) { - res = f(meth, NULL, type_obj); - Py_DECREF(meth); - if (unlikely(!res)) goto bad; - meth = res; - } - res = __Pyx_PyObject_FastCallDict(meth, NULL, 0, mkw); - Py_DECREF(meth); - if (unlikely(!res)) goto bad; - Py_DECREF(res); - goto done; - } else if (unlikely(PyErr_Occurred())) { - goto bad; - } - } -done: - Py_XDECREF(mro); - return type_obj; -bad: - Py_XDECREF(mro); - Py_DECREF(type_obj); - return NULL; -#else - PyObject *super_type, *super, *func, *res; -#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type) - super_type = __Pyx_GetBuiltinName(__pyx_n_s_super); -#else - super_type = (PyObject*) &PySuper_Type; - (void) &__Pyx_GetBuiltinName; -#endif - super = likely(super_type) ? __Pyx_PyObject_Call2Args(super_type, type_obj, type_obj) : NULL; -#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type) - Py_XDECREF(super_type); -#endif - if (unlikely(!super)) { - Py_CLEAR(type_obj); - goto done; - } - func = __Pyx_PyObject_GetAttrStrNoError(super, __pyx_n_s_init_subclass); - Py_DECREF(super); - if (likely(!func)) { - if (unlikely(PyErr_Occurred())) - Py_CLEAR(type_obj); - goto done; - } - res = __Pyx_PyObject_FastCallDict(func, NULL, 0, mkw); - Py_DECREF(func); - if (unlikely(!res)) - Py_CLEAR(type_obj); - Py_XDECREF(res); -done: - return type_obj; -#endif -} -#endif static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass) { @@ -105827,7 +93607,7 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj PyObject *owned_metaclass = NULL; PyObject *margs[4] = {NULL, name, bases, dict}; if (allow_py2_metaclass) { - owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); + owned_metaclass = PyObject_GetItem(dict, __pyx_mstate_global->__pyx_n_u_metaclass); if (owned_metaclass) { metaclass = owned_metaclass; } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { @@ -105843,86 +93623,149 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj return NULL; owned_metaclass = metaclass; } - result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, -#if PY_VERSION_HEX < 0x030600A4 - (metaclass == (PyObject*)&PyType_Type) ? NULL : mkw -#else - mkw -#endif - ); + result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); Py_XDECREF(owned_metaclass); -#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS - if (likely(result) && likely(PyType_Check(result))) { - if (unlikely(__Pyx_SetNamesPEP487(result) < 0)) { - Py_CLEAR(result); - } else { - result = __Pyx_InitSubclassPEP487(result, mkw); + return result; +} + +/* ListPack */ +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...) { + va_list va; + PyObject *l = PyList_New(n); + va_start(va, n); + if (unlikely(!l)) goto end; + for (Py_ssize_t i=0; i= 3 - if (level == -1) { - if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, 1); - if (unlikely(!module)) { - if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) - goto bad; - PyErr_Clear(); - } - } - level = 0; + 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, level); +} + /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); @@ -105936,11 +93779,12 @@ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { if (unlikely(!module_name_str)) { goto modbad; } module_name = PyUnicode_FromString(module_name_str); if (unlikely(!module_name)) { goto modbad; } - module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__43); + module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__14); if (unlikely(!module_dot)) { goto modbad; } full_name = PyUnicode_Concat(module_dot, name); if (unlikely(!full_name)) { goto modbad; } - #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ + CYTHON_COMPILING_IN_GRAAL { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) @@ -105956,170 +93800,36 @@ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { Py_XDECREF(module_name); } if (unlikely(!value)) { - PyErr_Format(PyExc_ImportError, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif + PyErr_Format(PyExc_ImportError, "cannot import name %S", name); } return value; } -/* ImportDottedModule */ -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { - PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; - if (unlikely(PyErr_Occurred())) { - PyErr_Clear(); - } - if (likely(PyTuple_GET_SIZE(parts_tuple) == 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( -#if PY_MAJOR_VERSION < 3 - PyExc_ImportError, - "No module named '%s'", PyString_AS_STRING(partial_name)); -#else -#if PY_VERSION_HEX >= 0x030600B1 - PyExc_ModuleNotFoundError, -#else - PyExc_ImportError, -#endif - "No module named '%U'", partial_name); -#endif -bad: - Py_XDECREF(sep); - Py_XDECREF(slice); - Py_XDECREF(partial_name); - return NULL; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { - PyObject *imported_module; -#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) - 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; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { - Py_ssize_t i, nparts; - nparts = PyTuple_GET_SIZE(parts_tuple); - 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 = PySequence_ITEM(parts_tuple, i); -#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; +/* 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); + return result; } #endif -static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if PY_MAJOR_VERSION < 3 - PyObject *module, *from_list, *star = __pyx_n_s__240; - CYTHON_UNUSED_VAR(parts_tuple); - from_list = PyList_New(1); - if (unlikely(!from_list)) - return NULL; - Py_INCREF(star); - PyList_SET_ITEM(from_list, 0, star); - module = __Pyx_Import(name, from_list, 0); - Py_DECREF(from_list); - return module; +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { +#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_CallOneArg; + (void) __Pyx_PyObject_Call2Args; + return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); #else - 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); -#endif -} -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 - PyObject *module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(module)) { - PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); - if (likely(spec)) { - PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_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(); + PyObject *method = NULL, *result; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_Call2Args(method, obj, arg); + Py_DECREF(method); + return result; } + if (unlikely(!method)) return NULL; + return __Pyx__PyObject_CallMethod1(method, arg); #endif - return __Pyx__ImportDottedModule(name, parts_tuple); -} - -/* ImportDottedModuleRelFirst */ -static PyObject *__Pyx_ImportDottedModuleRelFirst(PyObject *name, PyObject *parts_tuple) { - PyObject *module; - PyObject *from_list = NULL; -#if PY_MAJOR_VERSION < 3 - PyObject *star = __pyx_n_s__240; - from_list = PyList_New(1); - if (unlikely(!from_list)) - return NULL; - Py_INCREF(star); - PyList_SET_ITEM(from_list, 0, star); -#endif - module = __Pyx_Import(name, from_list, -1); - Py_XDECREF(from_list); - if (module) { - #if PY_MAJOR_VERSION >= 3 - if (parts_tuple) { - module = __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); - } - #endif - return module; - } - if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) - return NULL; - PyErr_Clear(); - return __Pyx_ImportDottedModule(name, parts_tuple); } /* append */ @@ -106127,7 +93837,7 @@ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { if (likely(PyList_CheckExact(L))) { if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1; } else { - PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x); + PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_mstate_global->__pyx_n_u_append, x); if (unlikely(!retval)) return -1; Py_DECREF(retval); @@ -106135,51 +93845,44 @@ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { return 0; } -/* CLineInTraceback */ -#ifndef CYTHON_CLINE_IN_TRACEBACK +/* 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_cython_runtime)) { + 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_cython_runtime); + cython_runtime_dict = __Pyx_PyProbablyModule_GetDict(__pyx_mstate_global->__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( - use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) - } else -#endif - { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); - if (use_cline_obj) { - use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; - Py_DECREF(use_cline_obj); - } else { - PyErr_Clear(); - use_cline = NULL; - } + use_cline, cython_runtime_dict, + __Pyx_PyDict_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False)) } - if (!use_cline) { - c_line = 0; - (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_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 */ -#if !CYTHON_COMPILING_IN_LIMITED_API +/* 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) { @@ -106201,70 +93904,109 @@ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int co return mid + 1; } } -static PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; +static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + if (unlikely(!code_line) || unlikely(!code_cache->entries)) { return NULL; } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { return NULL; } - code_object = __pyx_code_cache.entries[pos].code_object; + code_object = code_cache->entries[pos].code_object; Py_INCREF(code_object); return code_object; } -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } +#endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); +#endif + return result; +#endif +} +static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) +{ int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = 64; - __pyx_code_cache.count = 1; + code_cache->entries = entries; + code_cache->max_count = 64; + code_cache->count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { - PyCodeObject* tmp = entries[pos].code_object; + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; entries[pos].code_object = code_object; + Py_INCREF(code_object); Py_DECREF(tmp); return; } - if (__pyx_code_cache.count == __pyx_code_cache.max_count) { - int new_max = __pyx_code_cache.max_count + 64; + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = new_max; + code_cache->entries = entries; + code_cache->max_count = new_max; } - for (i=__pyx_code_cache.count; i>pos; i--) { + for (i=code_cache->count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; - __pyx_code_cache.count++; + code_cache->count++; Py_INCREF(code_object); } +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + return; + } +#endif + __pyx__insert_code_object(code_cache, code_line, code_object); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); #endif +#endif +} /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif @@ -106278,35 +94020,12 @@ static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; replace = PyObject_GetAttrString(code, "replace"); if (likely(replace)) { - PyObject *result; - result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); Py_DECREF(replace); return result; } PyErr_Clear(); - #if __PYX_LIMITED_VERSION_HEX < 0x030780000 - { - PyObject *compiled = NULL, *result = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; - compiled = Py_CompileString( - "out = type(code)(\n" - " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" - " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" - " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" - " code.co_lnotab)\n", "", Py_file_input); - if (!compiled) return NULL; - result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); - Py_DECREF(compiled); - if (!result) PyErr_Print(); - Py_DECREF(result); - result = PyDict_GetItemString(scratch_dict, "out"); - if (result) Py_INCREF(result); - return result; - } - #else return NULL; - #endif } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { @@ -106315,24 +94034,33 @@ 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 = Py_CompileString("_getframe()", filename, Py_eval_input); - 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 (unlikely(!py_funcname)) goto bad; - dict = PyDict_New(); - if (unlikely(!dict)) goto bad; - { - PyObject *old_code_object = code_object; - code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); - Py_DECREF(old_code_object); + code_object = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + 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; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); + } else { + dict = PyDict_New(); } - if (unlikely(!code_object)) goto bad; getframe = PySys_GetObject("_getframe"); if (unlikely(!getframe)) goto bad; if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; @@ -106358,58 +94086,17 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; - #if PY_MAJOR_VERSION < 3 - PyObject *py_srcfile = NULL; - py_srcfile = PyString_FromString(filename); - if (!py_srcfile) goto bad; - #endif if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; - #endif } - else { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromString(funcname); - if (!py_funcname) goto bad; - #endif - } - #if PY_MAJOR_VERSION < 3 - py_code = __Pyx_PyCode_New( - 0, - 0, - 0, - 0, - 0, - 0, - __pyx_empty_bytes, /*PyObject *code,*/ - __pyx_empty_tuple, /*PyObject *consts,*/ - __pyx_empty_tuple, /*PyObject *names,*/ - __pyx_empty_tuple, /*PyObject *varnames,*/ - __pyx_empty_tuple, /*PyObject *freevars,*/ - __pyx_empty_tuple, /*PyObject *cellvars,*/ - py_srcfile, /*PyObject *filename,*/ - py_funcname, /*PyObject *name,*/ - py_line, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); - Py_DECREF(py_srcfile); - #else py_code = PyCode_NewEmpty(filename, funcname, py_line); - #endif Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_srcfile); - #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, @@ -106440,7 +94127,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ - __pyx_d, /*PyObject *globals,*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; @@ -106782,8 +94469,162 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, #endif #endif +/* Declarations */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { + return ::std::complex< long double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { + return x + y*(__pyx_t_long_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { + __pyx_t_long_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) +#else + static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + if (b.imag == 0) { + return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsl(b.real) >= fabsl(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + long double r = b.imag / b.real; + long double s = (long double)(1.0) / (b.real + b.imag * r); + return __pyx_t_long_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + long double r = b.real / b.imag; + long double s = (long double)(1.0) / (b.imag + b.real * r); + return __pyx_t_long_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + if (b.imag == 0) { + return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + long double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_long_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex a) { + __pyx_t_long_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex a) { + __pyx_t_long_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtl(z.real*z.real + z.imag*z.imag); + #else + return hypotl(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + long double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + long double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_long__double(a, a); + case 3: + z = __Pyx_c_prod_long__double(a, a); + return __Pyx_c_prod_long__double(z, a); + case 4: + z = __Pyx_c_prod_long__double(a, a); + return __Pyx_c_prod_long__double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if ((b.imag == 0) && (a.real >= 0)) { + z.real = powl(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2l(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_long__double(a); + theta = atan2l(a.imag, a.real); + } + lnr = logl(r); + z_r = expl(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosl(z_theta); + z.imag = z_r * sinl(z_theta); + return z; + } + #endif +#endif + /* CIntFromPy */ -static CYTHON_INLINE TA_RetCode __Pyx_PyInt_As_TA_RetCode(PyObject *x) { +static CYTHON_INLINE TA_RetCode __Pyx_PyLong_As_TA_RetCode(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -106793,256 +94634,233 @@ static CYTHON_INLINE TA_RetCode __Pyx_PyInt_As_TA_RetCode(PyObject *x) { #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(TA_RetCode) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (TA_RetCode) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + if (unlikely(!PyLong_Check(x))) { + TA_RetCode val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (TA_RetCode) -1; + val = __Pyx_PyLong_As_TA_RetCode(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(TA_RetCode) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RetCode) >= 2 * PyLong_SHIFT)) { - return (TA_RetCode) (((((TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])); - } + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(TA_RetCode) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RetCode) >= 2 * PyLong_SHIFT)) { + return (TA_RetCode) (((((TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])); } - break; - case 3: - if ((8 * sizeof(TA_RetCode) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RetCode) >= 3 * PyLong_SHIFT)) { - return (TA_RetCode) (((((((TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])); - } + } + break; + case 3: + if ((8 * sizeof(TA_RetCode) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RetCode) >= 3 * PyLong_SHIFT)) { + return (TA_RetCode) (((((((TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])); } - break; - case 4: - if ((8 * sizeof(TA_RetCode) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RetCode) >= 4 * PyLong_SHIFT)) { - return (TA_RetCode) (((((((((TA_RetCode)digits[3]) << PyLong_SHIFT) | (TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])); - } + } + break; + case 4: + if ((8 * sizeof(TA_RetCode) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RetCode) >= 4 * PyLong_SHIFT)) { + return (TA_RetCode) (((((((((TA_RetCode)digits[3]) << PyLong_SHIFT) | (TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])); } - break; - } + } + break; } + } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } #else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_RetCode) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#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)) + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (TA_RetCode) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } #endif - } - } else { + if ((sizeof(TA_RetCode) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(TA_RetCode) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { #if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(TA_RetCode) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT)) { - return (TA_RetCode) (((TA_RetCode)-1)*(((((TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); - } + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(TA_RetCode) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT)) { + return (TA_RetCode) (((TA_RetCode)-1)*(((((TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); } - break; - case 2: - if ((8 * sizeof(TA_RetCode) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT)) { - return (TA_RetCode) ((((((TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); - } + } + break; + case 2: + if ((8 * sizeof(TA_RetCode) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT)) { + return (TA_RetCode) ((((((TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); } - break; - case -3: - if ((8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT)) { - return (TA_RetCode) (((TA_RetCode)-1)*(((((((TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); - } + } + break; + case -3: + if ((8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT)) { + return (TA_RetCode) (((TA_RetCode)-1)*(((((((TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); } - break; - case 3: - if ((8 * sizeof(TA_RetCode) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT)) { - return (TA_RetCode) ((((((((TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); - } + } + break; + case 3: + if ((8 * sizeof(TA_RetCode) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT)) { + return (TA_RetCode) ((((((((TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); } - break; - case -4: - if ((8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RetCode) - 1 > 4 * PyLong_SHIFT)) { - return (TA_RetCode) (((TA_RetCode)-1)*(((((((((TA_RetCode)digits[3]) << PyLong_SHIFT) | (TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); - } + } + break; + case -4: + if ((8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RetCode) - 1 > 4 * PyLong_SHIFT)) { + return (TA_RetCode) (((TA_RetCode)-1)*(((((((((TA_RetCode)digits[3]) << PyLong_SHIFT) | (TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); } - break; - case 4: - if ((8 * sizeof(TA_RetCode) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RetCode) - 1 > 4 * PyLong_SHIFT)) { - return (TA_RetCode) ((((((((((TA_RetCode)digits[3]) << PyLong_SHIFT) | (TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); - } + } + break; + case 4: + if ((8 * sizeof(TA_RetCode) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RetCode) - 1 > 4 * PyLong_SHIFT)) { + return (TA_RetCode) ((((((((((TA_RetCode)digits[3]) << PyLong_SHIFT) | (TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]))); } - break; - } + } + break; } + } #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 - } + if ((sizeof(TA_RetCode) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, long, PyLong_AsLong(x)) + } else if ((sizeof(TA_RetCode) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + TA_RetCode val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (TA_RetCode) -1; + assert(PyLong_CheckExact(v)); } { - TA_RetCode val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (TA_RetCode) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (TA_RetCode) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_RetCode) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (TA_RetCode) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (TA_RetCode) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(TA_RetCode) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((TA_RetCode) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(TA_RetCode) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((TA_RetCode) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((TA_RetCode) 1) << (sizeof(TA_RetCode) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (TA_RetCode) -1; } - return (TA_RetCode) -1; + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (TA_RetCode) -1; + } else { + stepval = v; + } + v = NULL; + val = (TA_RetCode) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(TA_RetCode) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((TA_RetCode) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(TA_RetCode) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((TA_RetCode) idigit) << bits; } - } else { - TA_RetCode val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (TA_RetCode) -1; - val = __Pyx_PyInt_As_TA_RetCode(tmp); - Py_DECREF(tmp); + if (!is_unsigned) { + if (unlikely(val & (((TA_RetCode) 1) << (sizeof(TA_RetCode) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (TA_RetCode) -1; return val; } raise_overflow: @@ -107056,7 +94874,7 @@ static CYTHON_INLINE TA_RetCode __Pyx_PyInt_As_TA_RetCode(PyObject *x) { } /* CIntFromPy */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -107066,256 +94884,233 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(int) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + if (unlikely(!PyLong_Check(x))) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } - break; - } + } + break; } + } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } #else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#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)) + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } #endif - } - } else { + if ((sizeof(int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { #if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } - break; - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } + } + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } - break; - case -3: - if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } + } + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } - break; - case -4: - if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } + } + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } - break; - } + } + break; } + } #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 - } + if ((sizeof(int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); } { - int val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (int) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (int) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (int) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (int) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (int) -1; } - return (int) -1; + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; } - } else { - int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); - Py_DECREF(tmp); + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (int) -1; return val; } raise_overflow: @@ -107329,7 +95124,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -107341,113 +95136,54 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyLong_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG + return PyLong_FromLong((long) value); } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { - int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(int), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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(int)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_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 PyInt_FromLong((long) value); - } else if (sizeof(TA_RetCode) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } 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 PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(TA_RetCode) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif +#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; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(TA_RetCode), + return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); #else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + 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)); + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) 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); } - result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); @@ -107457,7 +95193,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_RetCode(TA_RetCode value) { } /* CIntFromPy */ -static CYTHON_INLINE TA_FuncUnstId __Pyx_PyInt_As_TA_FuncUnstId(PyObject *x) { +static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -107467,256 +95203,233 @@ static CYTHON_INLINE TA_FuncUnstId __Pyx_PyInt_As_TA_FuncUnstId(PyObject *x) { #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(TA_FuncUnstId) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (TA_FuncUnstId) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + if (unlikely(!PyLong_Check(x))) { + TA_FuncUnstId val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (TA_FuncUnstId) -1; + val = __Pyx_PyLong_As_TA_FuncUnstId(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(TA_FuncUnstId) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_FuncUnstId) >= 2 * PyLong_SHIFT)) { - return (TA_FuncUnstId) (((((TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])); - } + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(TA_FuncUnstId) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_FuncUnstId) >= 2 * PyLong_SHIFT)) { + return (TA_FuncUnstId) (((((TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])); } - break; - case 3: - if ((8 * sizeof(TA_FuncUnstId) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_FuncUnstId) >= 3 * PyLong_SHIFT)) { - return (TA_FuncUnstId) (((((((TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])); - } + } + break; + case 3: + if ((8 * sizeof(TA_FuncUnstId) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_FuncUnstId) >= 3 * PyLong_SHIFT)) { + return (TA_FuncUnstId) (((((((TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])); } - break; - case 4: - if ((8 * sizeof(TA_FuncUnstId) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_FuncUnstId) >= 4 * PyLong_SHIFT)) { - return (TA_FuncUnstId) (((((((((TA_FuncUnstId)digits[3]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])); - } + } + break; + case 4: + if ((8 * sizeof(TA_FuncUnstId) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_FuncUnstId) >= 4 * PyLong_SHIFT)) { + return (TA_FuncUnstId) (((((((((TA_FuncUnstId)digits[3]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])); } - break; - } + } + break; } + } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } #else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_FuncUnstId) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#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)) + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (TA_FuncUnstId) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } #endif - } - } else { + if ((sizeof(TA_FuncUnstId) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(TA_FuncUnstId) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { #if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(TA_FuncUnstId) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT)) { - return (TA_FuncUnstId) (((TA_FuncUnstId)-1)*(((((TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); - } + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(TA_FuncUnstId) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT)) { + return (TA_FuncUnstId) (((TA_FuncUnstId)-1)*(((((TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); } - break; - case 2: - if ((8 * sizeof(TA_FuncUnstId) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT)) { - return (TA_FuncUnstId) ((((((TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); - } + } + break; + case 2: + if ((8 * sizeof(TA_FuncUnstId) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT)) { + return (TA_FuncUnstId) ((((((TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); } - break; - case -3: - if ((8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT)) { - return (TA_FuncUnstId) (((TA_FuncUnstId)-1)*(((((((TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); - } + } + break; + case -3: + if ((8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT)) { + return (TA_FuncUnstId) (((TA_FuncUnstId)-1)*(((((((TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); } - break; - case 3: - if ((8 * sizeof(TA_FuncUnstId) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT)) { - return (TA_FuncUnstId) ((((((((TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); - } + } + break; + case 3: + if ((8 * sizeof(TA_FuncUnstId) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT)) { + return (TA_FuncUnstId) ((((((((TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); } - break; - case -4: - if ((8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 4 * PyLong_SHIFT)) { - return (TA_FuncUnstId) (((TA_FuncUnstId)-1)*(((((((((TA_FuncUnstId)digits[3]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); - } + } + break; + case -4: + if ((8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 4 * PyLong_SHIFT)) { + return (TA_FuncUnstId) (((TA_FuncUnstId)-1)*(((((((((TA_FuncUnstId)digits[3]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); } - break; - case 4: - if ((8 * sizeof(TA_FuncUnstId) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 4 * PyLong_SHIFT)) { - return (TA_FuncUnstId) ((((((((((TA_FuncUnstId)digits[3]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); - } + } + break; + case 4: + if ((8 * sizeof(TA_FuncUnstId) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 4 * PyLong_SHIFT)) { + return (TA_FuncUnstId) ((((((((((TA_FuncUnstId)digits[3]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]))); } - break; - } + } + break; } + } #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 - } + if ((sizeof(TA_FuncUnstId) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, long, PyLong_AsLong(x)) + } else if ((sizeof(TA_FuncUnstId) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + TA_FuncUnstId val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (TA_FuncUnstId) -1; + assert(PyLong_CheckExact(v)); } { - TA_FuncUnstId val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (TA_FuncUnstId) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (TA_FuncUnstId) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_FuncUnstId) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (TA_FuncUnstId) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (TA_FuncUnstId) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(TA_FuncUnstId) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((TA_FuncUnstId) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(TA_FuncUnstId) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((TA_FuncUnstId) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((TA_FuncUnstId) 1) << (sizeof(TA_FuncUnstId) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (TA_FuncUnstId) -1; } - return (TA_FuncUnstId) -1; + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (TA_FuncUnstId) -1; + } else { + stepval = v; + } + v = NULL; + val = (TA_FuncUnstId) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(TA_FuncUnstId) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((TA_FuncUnstId) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(TA_FuncUnstId) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((TA_FuncUnstId) idigit) << bits; } - } else { - TA_FuncUnstId val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (TA_FuncUnstId) -1; - val = __Pyx_PyInt_As_TA_FuncUnstId(tmp); - Py_DECREF(tmp); + if (!is_unsigned) { + if (unlikely(val & (((TA_FuncUnstId) 1) << (sizeof(TA_FuncUnstId) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (TA_FuncUnstId) -1; return val; } raise_overflow: @@ -107730,7 +95443,7 @@ static CYTHON_INLINE TA_FuncUnstId __Pyx_PyInt_As_TA_FuncUnstId(PyObject *x) { } /* CIntFromPy */ -static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { +static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -107740,256 +95453,233 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(unsigned int) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (unsigned int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + if (unlikely(!PyLong_Check(x))) { + unsigned int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (unsigned int) -1; + val = __Pyx_PyLong_As_unsigned_int(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT)) { - return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); - } + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT)) { + return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } - break; - case 3: - if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT)) { - return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); - } + } + break; + case 3: + if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT)) { + return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } - break; - case 4: - if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT)) { - return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); - } + } + break; + case 4: + if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT)) { + return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } - break; - } + } + break; } + } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } #else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (unsigned int) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#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)) + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } #endif - } - } else { + if ((sizeof(unsigned int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { #if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { - return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } - break; - case 2: - if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { - return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } + } + break; + case 2: + if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } - break; - case -3: - if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { - return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } + } + break; + case -3: + if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } - break; - case 3: - if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { - return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } + } + break; + case 3: + if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } - break; - case -4: - if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) { - return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } + } + break; + case -4: + if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } - break; - case 4: - if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) { - return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } + } + break; + case 4: + if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } - break; - } + } + break; } + } #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 - } + if ((sizeof(unsigned int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) + } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + unsigned int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (unsigned int) -1; + assert(PyLong_CheckExact(v)); } { - unsigned int val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (unsigned int) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (unsigned int) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (unsigned int) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (unsigned int) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (unsigned int) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((unsigned int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((unsigned int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (unsigned int) -1; } - return (unsigned int) -1; + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (unsigned int) -1; + } else { + stepval = v; + } + v = NULL; + val = (unsigned int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((unsigned int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((unsigned int) idigit) << bits; } - } else { - unsigned int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (unsigned int) -1; - val = __Pyx_PyInt_As_unsigned_int(tmp); - Py_DECREF(tmp); + if (!is_unsigned) { + if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (unsigned int) -1; return val; } raise_overflow: @@ -108003,7 +95693,7 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -108015,49 +95705,54 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned int) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyLong_FromLong((long) value); } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(unsigned int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG + return PyLong_FromLong((long) value); } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { - int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 +#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(unsigned int), little, !is_unsigned); #else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + 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(unsigned int)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) 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); } - result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); @@ -108067,7 +95762,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) } /* CIntFromPy */ -static CYTHON_INLINE TA_Compatibility __Pyx_PyInt_As_TA_Compatibility(PyObject *x) { +static CYTHON_INLINE TA_Compatibility __Pyx_PyLong_As_TA_Compatibility(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -108077,256 +95772,233 @@ static CYTHON_INLINE TA_Compatibility __Pyx_PyInt_As_TA_Compatibility(PyObject * #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(TA_Compatibility) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (TA_Compatibility) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + if (unlikely(!PyLong_Check(x))) { + TA_Compatibility val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (TA_Compatibility) -1; + val = __Pyx_PyLong_As_TA_Compatibility(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(TA_Compatibility) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_Compatibility) >= 2 * PyLong_SHIFT)) { - return (TA_Compatibility) (((((TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])); - } + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(TA_Compatibility) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_Compatibility) >= 2 * PyLong_SHIFT)) { + return (TA_Compatibility) (((((TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])); } - break; - case 3: - if ((8 * sizeof(TA_Compatibility) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_Compatibility) >= 3 * PyLong_SHIFT)) { - return (TA_Compatibility) (((((((TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])); - } + } + break; + case 3: + if ((8 * sizeof(TA_Compatibility) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_Compatibility) >= 3 * PyLong_SHIFT)) { + return (TA_Compatibility) (((((((TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])); } - break; - case 4: - if ((8 * sizeof(TA_Compatibility) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_Compatibility) >= 4 * PyLong_SHIFT)) { - return (TA_Compatibility) (((((((((TA_Compatibility)digits[3]) << PyLong_SHIFT) | (TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])); - } + } + break; + case 4: + if ((8 * sizeof(TA_Compatibility) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_Compatibility) >= 4 * PyLong_SHIFT)) { + return (TA_Compatibility) (((((((((TA_Compatibility)digits[3]) << PyLong_SHIFT) | (TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])); } - break; - } + } + break; } + } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } #else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_Compatibility) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#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)) + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (TA_Compatibility) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } #endif - } - } else { + if ((sizeof(TA_Compatibility) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(TA_Compatibility) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { #if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(TA_Compatibility) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT)) { - return (TA_Compatibility) (((TA_Compatibility)-1)*(((((TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); - } + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(TA_Compatibility) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT)) { + return (TA_Compatibility) (((TA_Compatibility)-1)*(((((TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); } - break; - case 2: - if ((8 * sizeof(TA_Compatibility) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT)) { - return (TA_Compatibility) ((((((TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); - } + } + break; + case 2: + if ((8 * sizeof(TA_Compatibility) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT)) { + return (TA_Compatibility) ((((((TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); } - break; - case -3: - if ((8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT)) { - return (TA_Compatibility) (((TA_Compatibility)-1)*(((((((TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); - } + } + break; + case -3: + if ((8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT)) { + return (TA_Compatibility) (((TA_Compatibility)-1)*(((((((TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); } - break; - case 3: - if ((8 * sizeof(TA_Compatibility) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT)) { - return (TA_Compatibility) ((((((((TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); - } + } + break; + case 3: + if ((8 * sizeof(TA_Compatibility) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT)) { + return (TA_Compatibility) ((((((((TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); } - break; - case -4: - if ((8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_Compatibility) - 1 > 4 * PyLong_SHIFT)) { - return (TA_Compatibility) (((TA_Compatibility)-1)*(((((((((TA_Compatibility)digits[3]) << PyLong_SHIFT) | (TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); - } + } + break; + case -4: + if ((8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_Compatibility) - 1 > 4 * PyLong_SHIFT)) { + return (TA_Compatibility) (((TA_Compatibility)-1)*(((((((((TA_Compatibility)digits[3]) << PyLong_SHIFT) | (TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); } - break; - case 4: - if ((8 * sizeof(TA_Compatibility) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_Compatibility) - 1 > 4 * PyLong_SHIFT)) { - return (TA_Compatibility) ((((((((((TA_Compatibility)digits[3]) << PyLong_SHIFT) | (TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); - } + } + break; + case 4: + if ((8 * sizeof(TA_Compatibility) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_Compatibility) - 1 > 4 * PyLong_SHIFT)) { + return (TA_Compatibility) ((((((((((TA_Compatibility)digits[3]) << PyLong_SHIFT) | (TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]))); } - break; - } + } + break; } + } #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 - } + if ((sizeof(TA_Compatibility) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, long, PyLong_AsLong(x)) + } else if ((sizeof(TA_Compatibility) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + TA_Compatibility val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (TA_Compatibility) -1; + assert(PyLong_CheckExact(v)); } { - TA_Compatibility val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (TA_Compatibility) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (TA_Compatibility) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_Compatibility) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (TA_Compatibility) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (TA_Compatibility) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(TA_Compatibility) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((TA_Compatibility) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(TA_Compatibility) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((TA_Compatibility) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((TA_Compatibility) 1) << (sizeof(TA_Compatibility) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (TA_Compatibility) -1; } - return (TA_Compatibility) -1; + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (TA_Compatibility) -1; + } else { + stepval = v; + } + v = NULL; + val = (TA_Compatibility) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(TA_Compatibility) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((TA_Compatibility) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(TA_Compatibility) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((TA_Compatibility) idigit) << bits; } - } else { - TA_Compatibility val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (TA_Compatibility) -1; - val = __Pyx_PyInt_As_TA_Compatibility(tmp); - Py_DECREF(tmp); + if (!is_unsigned) { + if (unlikely(val & (((TA_Compatibility) 1) << (sizeof(TA_Compatibility) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (TA_Compatibility) -1; return val; } raise_overflow: @@ -108340,7 +96012,7 @@ static CYTHON_INLINE TA_Compatibility __Pyx_PyInt_As_TA_Compatibility(PyObject * } /* CIntFromPy */ -static CYTHON_INLINE TA_CandleSettingType __Pyx_PyInt_As_TA_CandleSettingType(PyObject *x) { +static CYTHON_INLINE TA_CandleSettingType __Pyx_PyLong_As_TA_CandleSettingType(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -108350,256 +96022,233 @@ static CYTHON_INLINE TA_CandleSettingType __Pyx_PyInt_As_TA_CandleSettingType(Py #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(TA_CandleSettingType) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (TA_CandleSettingType) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + if (unlikely(!PyLong_Check(x))) { + TA_CandleSettingType val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (TA_CandleSettingType) -1; + val = __Pyx_PyLong_As_TA_CandleSettingType(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(TA_CandleSettingType) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_CandleSettingType) >= 2 * PyLong_SHIFT)) { - return (TA_CandleSettingType) (((((TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])); - } + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(TA_CandleSettingType) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_CandleSettingType) >= 2 * PyLong_SHIFT)) { + return (TA_CandleSettingType) (((((TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])); } - break; - case 3: - if ((8 * sizeof(TA_CandleSettingType) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_CandleSettingType) >= 3 * PyLong_SHIFT)) { - return (TA_CandleSettingType) (((((((TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])); - } + } + break; + case 3: + if ((8 * sizeof(TA_CandleSettingType) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_CandleSettingType) >= 3 * PyLong_SHIFT)) { + return (TA_CandleSettingType) (((((((TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])); } - break; - case 4: - if ((8 * sizeof(TA_CandleSettingType) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_CandleSettingType) >= 4 * PyLong_SHIFT)) { - return (TA_CandleSettingType) (((((((((TA_CandleSettingType)digits[3]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])); - } + } + break; + case 4: + if ((8 * sizeof(TA_CandleSettingType) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_CandleSettingType) >= 4 * PyLong_SHIFT)) { + return (TA_CandleSettingType) (((((((((TA_CandleSettingType)digits[3]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])); } - break; - } + } + break; } + } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } #else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_CandleSettingType) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#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)) + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (TA_CandleSettingType) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } #endif - } - } else { + if ((sizeof(TA_CandleSettingType) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(TA_CandleSettingType) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { #if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(TA_CandleSettingType) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT)) { - return (TA_CandleSettingType) (((TA_CandleSettingType)-1)*(((((TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); - } + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(TA_CandleSettingType) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT)) { + return (TA_CandleSettingType) (((TA_CandleSettingType)-1)*(((((TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); } - break; - case 2: - if ((8 * sizeof(TA_CandleSettingType) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT)) { - return (TA_CandleSettingType) ((((((TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); - } + } + break; + case 2: + if ((8 * sizeof(TA_CandleSettingType) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT)) { + return (TA_CandleSettingType) ((((((TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); } - break; - case -3: - if ((8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT)) { - return (TA_CandleSettingType) (((TA_CandleSettingType)-1)*(((((((TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); - } + } + break; + case -3: + if ((8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT)) { + return (TA_CandleSettingType) (((TA_CandleSettingType)-1)*(((((((TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); } - break; - case 3: - if ((8 * sizeof(TA_CandleSettingType) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT)) { - return (TA_CandleSettingType) ((((((((TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); - } + } + break; + case 3: + if ((8 * sizeof(TA_CandleSettingType) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT)) { + return (TA_CandleSettingType) ((((((((TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); } - break; - case -4: - if ((8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 4 * PyLong_SHIFT)) { - return (TA_CandleSettingType) (((TA_CandleSettingType)-1)*(((((((((TA_CandleSettingType)digits[3]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); - } + } + break; + case -4: + if ((8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 4 * PyLong_SHIFT)) { + return (TA_CandleSettingType) (((TA_CandleSettingType)-1)*(((((((((TA_CandleSettingType)digits[3]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); } - break; - case 4: - if ((8 * sizeof(TA_CandleSettingType) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 4 * PyLong_SHIFT)) { - return (TA_CandleSettingType) ((((((((((TA_CandleSettingType)digits[3]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); - } + } + break; + case 4: + if ((8 * sizeof(TA_CandleSettingType) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 4 * PyLong_SHIFT)) { + return (TA_CandleSettingType) ((((((((((TA_CandleSettingType)digits[3]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]))); } - break; - } + } + break; } + } #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 - } + if ((sizeof(TA_CandleSettingType) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, long, PyLong_AsLong(x)) + } else if ((sizeof(TA_CandleSettingType) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + TA_CandleSettingType val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (TA_CandleSettingType) -1; + assert(PyLong_CheckExact(v)); } { - TA_CandleSettingType val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (TA_CandleSettingType) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (TA_CandleSettingType) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_CandleSettingType) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (TA_CandleSettingType) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (TA_CandleSettingType) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(TA_CandleSettingType) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((TA_CandleSettingType) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(TA_CandleSettingType) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((TA_CandleSettingType) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((TA_CandleSettingType) 1) << (sizeof(TA_CandleSettingType) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (TA_CandleSettingType) -1; } - return (TA_CandleSettingType) -1; + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (TA_CandleSettingType) -1; + } else { + stepval = v; + } + v = NULL; + val = (TA_CandleSettingType) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(TA_CandleSettingType) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((TA_CandleSettingType) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(TA_CandleSettingType) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((TA_CandleSettingType) idigit) << bits; } - } else { - TA_CandleSettingType val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (TA_CandleSettingType) -1; - val = __Pyx_PyInt_As_TA_CandleSettingType(tmp); - Py_DECREF(tmp); + if (!is_unsigned) { + if (unlikely(val & (((TA_CandleSettingType) 1) << (sizeof(TA_CandleSettingType) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (TA_CandleSettingType) -1; return val; } raise_overflow: @@ -108613,7 +96262,7 @@ static CYTHON_INLINE TA_CandleSettingType __Pyx_PyInt_As_TA_CandleSettingType(Py } /* CIntFromPy */ -static CYTHON_INLINE TA_RangeType __Pyx_PyInt_As_TA_RangeType(PyObject *x) { +static CYTHON_INLINE TA_RangeType __Pyx_PyLong_As_TA_RangeType(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -108623,256 +96272,233 @@ static CYTHON_INLINE TA_RangeType __Pyx_PyInt_As_TA_RangeType(PyObject *x) { #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(TA_RangeType) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (TA_RangeType) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + if (unlikely(!PyLong_Check(x))) { + TA_RangeType val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (TA_RangeType) -1; + val = __Pyx_PyLong_As_TA_RangeType(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(TA_RangeType) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RangeType) >= 2 * PyLong_SHIFT)) { - return (TA_RangeType) (((((TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])); - } + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(TA_RangeType) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RangeType) >= 2 * PyLong_SHIFT)) { + return (TA_RangeType) (((((TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])); } - break; - case 3: - if ((8 * sizeof(TA_RangeType) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RangeType) >= 3 * PyLong_SHIFT)) { - return (TA_RangeType) (((((((TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])); - } + } + break; + case 3: + if ((8 * sizeof(TA_RangeType) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RangeType) >= 3 * PyLong_SHIFT)) { + return (TA_RangeType) (((((((TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])); } - break; - case 4: - if ((8 * sizeof(TA_RangeType) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RangeType) >= 4 * PyLong_SHIFT)) { - return (TA_RangeType) (((((((((TA_RangeType)digits[3]) << PyLong_SHIFT) | (TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])); - } + } + break; + case 4: + if ((8 * sizeof(TA_RangeType) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RangeType) >= 4 * PyLong_SHIFT)) { + return (TA_RangeType) (((((((((TA_RangeType)digits[3]) << PyLong_SHIFT) | (TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])); } - break; - } + } + break; } + } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } #else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_RangeType) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#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)) + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (TA_RangeType) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } #endif - } - } else { + if ((sizeof(TA_RangeType) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(TA_RangeType) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { #if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(TA_RangeType) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT)) { - return (TA_RangeType) (((TA_RangeType)-1)*(((((TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); - } + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(TA_RangeType) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT)) { + return (TA_RangeType) (((TA_RangeType)-1)*(((((TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); } - break; - case 2: - if ((8 * sizeof(TA_RangeType) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT)) { - return (TA_RangeType) ((((((TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); - } + } + break; + case 2: + if ((8 * sizeof(TA_RangeType) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT)) { + return (TA_RangeType) ((((((TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); } - break; - case -3: - if ((8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT)) { - return (TA_RangeType) (((TA_RangeType)-1)*(((((((TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); - } + } + break; + case -3: + if ((8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT)) { + return (TA_RangeType) (((TA_RangeType)-1)*(((((((TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); } - break; - case 3: - if ((8 * sizeof(TA_RangeType) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT)) { - return (TA_RangeType) ((((((((TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); - } + } + break; + case 3: + if ((8 * sizeof(TA_RangeType) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT)) { + return (TA_RangeType) ((((((((TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); } - break; - case -4: - if ((8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RangeType) - 1 > 4 * PyLong_SHIFT)) { - return (TA_RangeType) (((TA_RangeType)-1)*(((((((((TA_RangeType)digits[3]) << PyLong_SHIFT) | (TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); - } + } + break; + case -4: + if ((8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RangeType) - 1 > 4 * PyLong_SHIFT)) { + return (TA_RangeType) (((TA_RangeType)-1)*(((((((((TA_RangeType)digits[3]) << PyLong_SHIFT) | (TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); } - break; - case 4: - if ((8 * sizeof(TA_RangeType) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(TA_RangeType) - 1 > 4 * PyLong_SHIFT)) { - return (TA_RangeType) ((((((((((TA_RangeType)digits[3]) << PyLong_SHIFT) | (TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); - } + } + break; + case 4: + if ((8 * sizeof(TA_RangeType) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(TA_RangeType) - 1 > 4 * PyLong_SHIFT)) { + return (TA_RangeType) ((((((((((TA_RangeType)digits[3]) << PyLong_SHIFT) | (TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]))); } - break; - } + } + break; } + } #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 - } + if ((sizeof(TA_RangeType) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, long, PyLong_AsLong(x)) + } else if ((sizeof(TA_RangeType) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + TA_RangeType val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (TA_RangeType) -1; + assert(PyLong_CheckExact(v)); } { - TA_RangeType val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (TA_RangeType) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (TA_RangeType) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (TA_RangeType) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (TA_RangeType) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (TA_RangeType) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(TA_RangeType) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((TA_RangeType) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(TA_RangeType) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((TA_RangeType) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((TA_RangeType) 1) << (sizeof(TA_RangeType) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (TA_RangeType) -1; } - return (TA_RangeType) -1; + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (TA_RangeType) -1; + } else { + stepval = v; + } + v = NULL; + val = (TA_RangeType) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(TA_RangeType) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((TA_RangeType) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(TA_RangeType) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((TA_RangeType) idigit) << bits; } - } else { - TA_RangeType val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (TA_RangeType) -1; - val = __Pyx_PyInt_As_TA_RangeType(tmp); - Py_DECREF(tmp); + if (!is_unsigned) { + if (unlikely(val & (((TA_RangeType) 1) << (sizeof(TA_RangeType) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (TA_RangeType) -1; return val; } raise_overflow: @@ -108886,7 +96512,7 @@ static CYTHON_INLINE TA_RangeType __Pyx_PyInt_As_TA_RangeType(PyObject *x) { } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -108898,49 +96524,54 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG + return PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { - int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 +#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(long), little, !is_unsigned); #else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + 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(long)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) 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); } - result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); @@ -108950,7 +96581,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInputParameterType value) { +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInputParameterType value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -108962,49 +96593,54 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptI const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(TA_OptInputParameterType) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyLong_FromLong((long) value); } else if (sizeof(TA_OptInputParameterType) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(TA_OptInputParameterType) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(TA_OptInputParameterType) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG + return PyLong_FromLong((long) value); } else if (sizeof(TA_OptInputParameterType) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { - int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 +#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_OptInputParameterType), little, !is_unsigned); #else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + 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_OptInputParameterType)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) 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); } - result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); @@ -109014,7 +96650,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptI } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_FuncFlags(TA_FuncFlags value) { +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_FuncFlags(TA_FuncFlags value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -109026,49 +96662,54 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_FuncFlags(TA_FuncFlags value) const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(TA_FuncFlags) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyLong_FromLong((long) value); } else if (sizeof(TA_FuncFlags) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(TA_FuncFlags) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(TA_FuncFlags) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG + return PyLong_FromLong((long) value); } else if (sizeof(TA_FuncFlags) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { - int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 +#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_FuncFlags), little, !is_unsigned); #else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + 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_FuncFlags)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) 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); } - result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); @@ -109078,7 +96719,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_FuncFlags(TA_FuncFlags value) } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_InputFlags(TA_InputFlags value) { +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_InputFlags(TA_InputFlags value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -109090,49 +96731,54 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_InputFlags(TA_InputFlags valu const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(TA_InputFlags) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyLong_FromLong((long) value); } else if (sizeof(TA_InputFlags) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(TA_InputFlags) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(TA_InputFlags) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG + return PyLong_FromLong((long) value); } else if (sizeof(TA_InputFlags) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { - int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 +#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_InputFlags), little, !is_unsigned); #else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + 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_InputFlags)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) 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); } - result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); @@ -109142,7 +96788,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_InputFlags(TA_InputFlags valu } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags value) { +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OutputFlags(TA_OutputFlags value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -109154,49 +96800,54 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(TA_OutputFlags) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyLong_FromLong((long) value); } else if (sizeof(TA_OutputFlags) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(TA_OutputFlags) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(TA_OutputFlags) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG + return PyLong_FromLong((long) value); } else if (sizeof(TA_OutputFlags) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { - int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 +#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_OutputFlags), little, !is_unsigned); #else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + 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_OutputFlags)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) 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); } - result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); @@ -109206,23 +96857,46 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va } /* FormatTypeName */ -#if CYTHON_COMPILING_IN_LIMITED_API +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 static __Pyx_TypeName -__Pyx_PyType_GetName(PyTypeObject* tp) +__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) { - PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, - __pyx_n_s_name_2); - if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { - PyErr_Clear(); - Py_XDECREF(name); - name = __Pyx_NewRef(__pyx_n_s__503); + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__15); } - return name; + goto done; } #endif /* CIntFromPy */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -109232,256 +96906,233 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(long) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (long) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { + if (unlikely(!PyLong_Check(x))) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } - break; - } + } + break; } + } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } #else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#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)) + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } #endif - } - } else { + if ((sizeof(long) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { #if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } - break; - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } + } + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } - break; - case -3: - if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } + } + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } - break; - case -4: - if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } + } + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } - break; - } + } + break; } + } #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 - } + if ((sizeof(long) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + long val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); } { - long val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (long) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (long) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (long) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (long) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { Py_DECREF(v); - if (likely(!ret)) - return val; + return (long) -1; } - return (long) -1; + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (long) -1; return val; } raise_overflow: @@ -109535,29 +97186,6 @@ static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, } return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); } -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - } - __Pyx_ErrRestore(exception, value, tb); - return res; -} -#else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { if (exc_type1) { return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); @@ -109565,21 +97193,15 @@ static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } } -#endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 for (i=0; i= 0x030B00A4 - return Py_Version & ~0xFFUL; -#else - const char* rt_version = Py_GetVersion(); - unsigned long version = 0; - unsigned long factor = 0x01000000UL; - unsigned int digit = 0; - int i = 0; - while (factor) { - while ('0' <= rt_version[i] && rt_version[i] <= '9') { - digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); +/* GetRuntimeVersion */ +#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; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; ++i; } - version += factor * digit; - if (rt_version[i] != '.') - break; - digit = 0; - factor >>= 8; - ++i; + __Pyx_cached_runtime_version = version; } - return 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 } + +/* CheckBinaryVersion */ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { const unsigned long MAJOR_MINOR = 0xFFFF0000UL; if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) @@ -109657,47 +97288,209 @@ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt } } -/* InitStrings */ -#if PY_MAJOR_VERSION >= 3 -static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { - if (t.is_unicode | t.is_str) { - if (t.intern) { - *str = PyUnicode_InternFromString(t.s); - } else if (t.encoding) { - *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); +/* NewCodeObj */ +#if CYTHON_COMPILING_IN_LIMITED_API + static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); } else { - *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - } else { - *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; } - if (!*str) - return -1; - if (PyObject_Hash(*str) == -1) - return -1; - return 0; -} +#elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + 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 !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 + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #if PY_MAJOR_VERSION >= 3 - __Pyx_InitString(*t, t->p); +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + PyObject *line_table, + PyObject *tuple_dedup_map +) { + 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; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + 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); + if (unlikely(!c_code_bytes)) goto done; + memset(c_code_bytes, 0, (size_t) code_len); + } + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + varnames_tuple_dedup, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table) ? line_table : __pyx_mstate_global->__pyx_empty_bytes + ); +done: + Py_XDECREF(code_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; +} + +/* 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 (t->is_unicode) { - *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); - } else if (t->intern) { - *t->p = PyString_InternFromString(t->s); - } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); - } - if (!*t->p) - return -1; - if (PyObject_Hash(*t->p) == -1) - return -1; + #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 - ++t; + #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 @@ -109723,31 +97516,30 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#if !CYTHON_PEP393_ENABLED -static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - char* defenc_c; - PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); - if (!defenc) return NULL; - defenc_c = PyBytes_AS_STRING(defenc); -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API { - char* end = defenc_c + PyBytes_GET_SIZE(defenc); - char* c; - for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { - PyUnicode_AsASCIIString(o); - return NULL; - } + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + PyUnicode_AsASCIIString(o); + return NULL; } + #endif + return result; } -#endif - *length = PyBytes_GET_SIZE(defenc); - return defenc_c; -} #else -static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); @@ -109759,25 +97551,25 @@ static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py #else return PyUnicode_AsUTF8AndSize(o, length); #endif -} #endif +} #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT - if ( -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - __Pyx_sys_getdefaultencoding_not_ascii && -#endif - PyUnicode_Check(o)) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + if (PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); - } else +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); #endif + } else { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); @@ -109800,9 +97592,8 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { Py_DECREF(x); return retval; } -static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { - __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); -#if PY_MAJOR_VERSION >= 3 +static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " @@ -109816,74 +97607,44 @@ static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const __Pyx_DECREF_TypeName(result_type_name); return result; } -#endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", - type_name, type_name, result_type_name); + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif - const char *name = NULL; PyObject *res = NULL; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x) || PyLong_Check(x))) -#else if (likely(PyLong_Check(x))) -#endif - return __Pyx_NewRef(x); + return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; - #if PY_MAJOR_VERSION < 3 - if (m && m->nb_int) { - name = "int"; - res = m->nb_int(x); - } - else if (m && m->nb_long) { - name = "long"; - res = m->nb_long(x); - } - #else if (likely(m && m->nb_int)) { - name = "int"; - res = m->nb_int(x); + res = m->nb_int(x); } - #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); + res = PyNumber_Long(x); } #endif if (likely(res)) { -#if PY_MAJOR_VERSION < 3 - if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { -#else - if (unlikely(!PyLong_CheckExact(res))) { -#endif - return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); - } + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, - "an integer is required"); + PyErr_SetString(PyExc_TypeError, + "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) { - if (sizeof(Py_ssize_t) >= sizeof(long)) - return PyInt_AS_LONG(b); - else - return PyInt_AsSsize_t(b); - } -#endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS if (likely(__Pyx_PyLong_IsCompact(b))) { @@ -109929,34 +97690,349 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { } x = PyNumber_Index(b); if (!x) return -1; - ival = PyInt_AsSsize_t(x); + ival = PyLong_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); -#if PY_MAJOR_VERSION < 3 - } else if (likely(PyInt_CheckExact(o))) { - return PyInt_AS_LONG(o); -#endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; - ival = PyInt_AsLong(x); + ival = PyLong_AsLong(x); Py_DECREF(x); return ival; } } +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(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); +} + + +/* MultiPhaseInitModuleState */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 +#else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 +#endif +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS +#error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" +#endif +#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#define __Pyx_ModuleStateLookup_Lock() +#define __Pyx_ModuleStateLookup_Unlock() +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 +static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; +#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(__cplusplus) && __cplusplus >= 201103L +#include +static std::mutex __Pyx_ModuleStateLookup_mutex; +#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() +#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) +#include +static mtx_t __Pyx_ModuleStateLookup_mutex; +static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; +static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); +} +#define __Pyx_ModuleStateLookup_Lock()\ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(HAVE_PTHREAD_H) +#include +static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; +#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(_WIN32) +#include // synchapi.h on its own doesn't work +static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; +#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#else +#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." +#endif +typedef struct { + int64_t id; + PyObject *module; +} __Pyx_InterpreterIdAndModule; +typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; +} __Pyx_ModuleStateLookupData; +#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; +#else +static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; +#endif +static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + if (begin->id == interpreterId) { + return begin; + } + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; } -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { - return PyInt_FromSize_t(ival); +static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; +#else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); +#endif + return result; + } } - +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); +} +#else +#define __Pyx_ModuleStateLookup_wait_until_no_readers() +#endif +static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; +} +static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; +} +static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); +#else + __Pyx_ModuleStateLookup_data = new_data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return result; +} +static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; +#endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); +#else + __Pyx_ModuleStateLookup_data = data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; +} +#endif /* #### Code section: utility_code_pragmas_end ### */ #ifdef _MSC_VER diff --git a/talib/_ta_lib.pxd b/talib/_ta_lib.pxd index 77bcd69df..21e64b220 100644 --- a/talib/_ta_lib.pxd +++ b/talib/_ta_lib.pxd @@ -1,88 +1,88 @@ -#cython: language_level=2, embedsignature=True +#cython: language_level=2 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 @@ -193,6 +193,8 @@ cdef extern from "ta-lib/ta_abstract.h": char* TA_FunctionDescriptionXML() cdef extern from "ta-lib/ta_func.h": + TA_RetCode TA_ACCBANDS(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outRealUpperBand[], double outRealMiddleBand[], double outRealLowerBand[]) + int TA_ACCBANDS_Lookback(int optInTimePeriod) TA_RetCode TA_ACOS(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_ACOS_Lookback() TA_RetCode TA_AD(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], const double inVolume[], int *outBegIdx, int *outNBElement, double outReal[]) @@ -219,6 +221,8 @@ cdef extern from "ta-lib/ta_func.h": int TA_ATR_Lookback(int optInTimePeriod) TA_RetCode TA_AVGPRICE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_AVGPRICE_Lookback() + TA_RetCode TA_AVGDEV(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_AVGDEV_Lookback(int optInTimePeriod) TA_RetCode TA_BBANDS(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInNbDevUp, double optInNbDevDn, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outRealUpperBand[], double outRealMiddleBand[], double outRealLowerBand[]) int TA_BBANDS_Lookback(int optInTimePeriod, double optInNbDevUp, double optInNbDevDn, TA_MAType optInMAType) TA_RetCode TA_BETA(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) @@ -383,6 +387,8 @@ cdef extern from "ta-lib/ta_func.h": int TA_HT_TRENDLINE_Lookback() TA_RetCode TA_HT_TRENDMODE(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_HT_TRENDMODE_Lookback() + TA_RetCode TA_IMI(int startIdx, int endIdx, const double inOpen[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_IMI_Lookback(int optInTimePeriod) TA_RetCode TA_KAMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_KAMA_Lookback(int optInTimePeriod) TA_RetCode TA_LINEARREG(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) diff --git a/talib/_ta_lib.pyi b/talib/_ta_lib.pyi new file mode 100644 index 000000000..4356269ff --- /dev/null +++ b/talib/_ta_lib.pyi @@ -0,0 +1,1983 @@ +import numpy as np +from enum import Enum +from typing import Tuple +from numpy.typing import NDArray + +class MA_Type(Enum): + SMA = 0 + EMA = 1 + WMA = 2 + DEMA = 3 + TEMA = 4 + TRIMA = 5 + KAMA = 6 + MAMA = 7 + T3 = 8 + +#Overlap Studies Functions + +def BBANDS( + real: NDArray[np.float64], + timeperiod: int= 5, + nbdevup: float= 2, + nbdevdn: float= 2, + matype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + +def DEMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def EMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def HT_TRENDLINE(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def KAMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def MA( + real: NDArray[np.float64], + timeperiod: int= 30, + matype: MA_Type = MA_Type.SMA + )-> NDArray[np.float64]: ... + +def MAMA( + real: NDArray[np.float64], + fastlimit: float= 0, + slowlimit: float= 0 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def MAVP( + real: NDArray[np.float64], + periods: float, + minperiod: int= 2, + maxperiod: int= 30, + matype: MA_Type = MA_Type.SMA + )-> NDArray[np.float64]: ... + +def MIDPOINT( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def MIDPRICE( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def SAR( + high: NDArray[np.float64], + low: NDArray[np.float64], + acceleration: float= 0, + maximum: float= 0 + )-> NDArray[np.float64]: ... + +def SAREXT( + high: NDArray[np.float64], + low: NDArray[np.float64], + startvalue: float= 0, + offsetonreverse: float= 0, + accelerationinitlong: float= 0, + accelerationlong: float= 0, + accelerationmaxlong: float= 0, + accelerationinitshort: float= 0, + accelerationshort: float= 0, + accelerationmaxshort: float= 0 + )-> NDArray[np.float64]: ... + +def SMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def T3( + real: NDArray[np.float64], + timeperiod: int= 5, + vfactor: float= 0 + )-> NDArray[np.float64]: ... + +def TEMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def TRIMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def WMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +#Momentum Indicator Functions + +def ADX( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def ADXR( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def APO( + real: NDArray[np.float64], + fastperiod: int= 12, + slowperiod: int= 26, + matype: MA_Type = MA_Type.SMA + )-> NDArray[np.float64]: ... + +def AROON( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def AROONOSC( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def BOP( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def CCI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def CMO( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def DX( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def MACD( + real: NDArray[np.float64], + fastperiod: int= 12, + slowperiod: int= 26, + signalperiod: int= 9 + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + +def MACDEXT( + real: NDArray[np.float64], + fastperiod: int= 12, + fastmatype: MA_Type = MA_Type.SMA, + slowperiod: int= 26, + slowmatype: MA_Type = MA_Type.SMA, + signalperiod: int= 9, + signalmatype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + +def MACDFIX( + real: NDArray[np.float64], + signalperiod: int= 9 + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + +def MFI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def MINUS_DI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def MINUS_DM( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def MOM( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def PLUS_DI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def PLUS_DM( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def PPO( + real: NDArray[np.float64], + fastperiod: int= 12, + slowperiod: int= 26, + matype: MA_Type = MA_Type.SMA + )-> NDArray[np.float64]: ... + +def ROC( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def ROCP( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def ROCR( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def ROCR100( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def RSI( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def STOCH( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + fastk_period: int= 5, + slowk_period: int= 3, + slowk_matype: MA_Type = MA_Type.SMA, + slowd_period: int= 3, + slowd_matype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def STOCHF( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + fastk_period: int= 5, + fastd_period: int= 3, + fastd_matype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def STOCHRSI( + real: NDArray[np.float64], + timeperiod: int= 14, + fastk_period: int= 5, + fastd_period: int= 3, + fastd_matype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def TRIX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def ULTOSC( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod1: int= 7, + timeperiod2: int= 14, + timeperiod3: int= 28 + )-> NDArray[np.float64]: ... + +def WILLR( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +#Volume Indicator Functions + +def AD( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def ADOSC( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64], + fastperiod: int= 3, + slowperiod: int= 10 + )-> NDArray[np.float64]: ... + +def OBV( + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +#Volatility Indicator Functions + +def ATR( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def NATR( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def TRANGE( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +# Price Transform Functions + +def AVGPRICE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def MEDPRICE( + high: NDArray[np.float64], + low: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def TYPPRICE( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def WCLPRICE( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +# Cycle Indicator Functions + +def HT_DCPERIOD(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def HT_DCPHASE(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def HT_PHASOR(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def HT_SINE(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def HT_TRENDMODE(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.int32]]: ... + +#Pattern Recognition Functions + +def CDL2CROWS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDL3BLACKCROWS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDL3INSIDE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDL3LINESTRIKE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDL3OUTSIDE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDL3STARSINSOUTH( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDL3WHITESOLDIERS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLABANDONEDBABY( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def CDLADVANCEBLOCK( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLBELTHOLD( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLBREAKAWAY( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLCLOSINGMARUBOZU( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLCONCEALBABYSWALL( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLCOUNTERATTACK( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLDARKCLOUDCOVER( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def CDLDOJI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLDOJISTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLDRAGONFLYDOJI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLENGULFING( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLEVENINGDOJISTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def CDLEVENINGSTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def CDLGAPSIDESIDEWHITE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLGRAVESTONEDOJI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLHAMMER( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLHANGINGMAN( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLHARAMI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLHARAMICROSS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLHIGHWAVE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLHIKKAKE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLHIKKAKEMOD( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLHOMINGPIGEON( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLIDENTICAL3CROWS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLINNECK( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLINVERTEDHAMMER( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLKICKING( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLKICKINGBYLENGTH( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLLADDERBOTTOM( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLLONGLEGGEDDOJI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLLONGLINE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLMARUBOZU( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLMATCHINGLOW( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLMATHOLD( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def CDLMORNINGDOJISTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def CDLMORNINGSTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def CDLONNECK( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLPIERCING( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLRICKSHAWMAN( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLRISEFALL3METHODS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLSEPARATINGLINES( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLSHOOTINGSTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLSHORTLINE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLSPINNINGTOP( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLSTALLEDPATTERN( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLSTICKSANDWICH( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLTAKURI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLTASUKIGAP( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLTHRUSTING( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLTRISTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLUNIQUE3RIVER( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLUPSIDEGAP2CROWS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def CDLXSIDEGAP3METHODS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +# Statistic Functions + +def BETA( + real0: NDArray[np.float64], + real1: NDArray[np.float64], + timeperiod: int= 5 + )-> NDArray[np.float64]: ... + +def CORREL( + real0: NDArray[np.float64], + real1: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def LINEARREG( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def LINEARREG_ANGLE( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def LINEARREG_INTERCEPT( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def LINEARREG_SLOPE( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def STDDEV( + real: NDArray[np.float64], + timeperiod: int= 5, + nbdev: float= 1 + )-> NDArray[np.float64]: ... + +def TSF( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def VAR( + real: NDArray[np.float64], + timeperiod: int= 5, + nbdev: float= 1 + )-> NDArray[np.float64]: ... + +# Math Transform Functions + +def ACOS(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def ASIN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def ATAN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def CEIL(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def COS(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def COSH(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def EXP(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def FLOOR(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def LN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def LOG10(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def SIN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def SINH(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def SQRT(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def TAN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def TANH(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +#Math Operator Functions + +def ADD( + real0: NDArray[np.float64], + real1: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def DIV( + real0: NDArray[np.float64], + real1: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def MAX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def MAXINDEX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.int32]: ... + +def MIN( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def MININDEX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.int32]: ... + +def MINMAX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def MINMAXINDEX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def MULT( + real0: NDArray[np.float64], + real1: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def SUB( + real0: NDArray[np.float64], + real1: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def SUM( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def ACCBANDS( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + +def AVGDEV( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def IMI( + open: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +#Overlap Studies Functions + +def stream_BBANDS( + real: NDArray[np.float64], + timeperiod: int= 5, + nbdevup: float= 2, + nbdevdn: float= 2, + matype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_DEMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_EMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_HT_TRENDLINE(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_KAMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_MA( + real: NDArray[np.float64], + timeperiod: int= 30, + matype: MA_Type = MA_Type.SMA + )-> NDArray[np.float64]: ... + +def stream_MAMA( + real: NDArray[np.float64], + fastlimit: float= 0, + slowlimit: float= 0 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_MAVP( + real: NDArray[np.float64], + periods: float, + minperiod: int= 2, + maxperiod: int= 30, + matype: MA_Type = MA_Type.SMA + )-> NDArray[np.float64]: ... + +def stream_MIDPOINT( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_MIDPRICE( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_SAR( + high: NDArray[np.float64], + low: NDArray[np.float64], + acceleration: float= 0, + maximum: float= 0 + )-> NDArray[np.float64]: ... + +def stream_SAREXT( + high: NDArray[np.float64], + low: NDArray[np.float64], + startvalue: float= 0, + offsetonreverse: float= 0, + accelerationinitlong: float= 0, + accelerationlong: float= 0, + accelerationmaxlong: float= 0, + accelerationinitshort: float= 0, + accelerationshort: float= 0, + accelerationmaxshort: float= 0 + )-> NDArray[np.float64]: ... + +def stream_SMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_T3( + real: NDArray[np.float64], + timeperiod: int= 5, + vfactor: float= 0 + )-> NDArray[np.float64]: ... + +def stream_TEMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_TRIMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_WMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +#Momentum Indicator Functions + +def stream_ADX( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_ADXR( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_APO( + real: NDArray[np.float64], + fastperiod: int= 12, + slowperiod: int= 26, + matype: MA_Type = MA_Type.SMA + )-> NDArray[np.float64]: ... + +def stream_AROON( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_AROONOSC( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_BOP( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_CCI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_CMO( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_DX( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_MACD( + real: NDArray[np.float64], + fastperiod: int= 12, + slowperiod: int= 26, + signalperiod: int= 9 + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_MACDEXT( + real: NDArray[np.float64], + fastperiod: int= 12, + fastmatype: MA_Type = MA_Type.SMA, + slowperiod: int= 26, + slowmatype: MA_Type = MA_Type.SMA, + signalperiod: int= 9, + signalmatype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_MACDFIX( + real: NDArray[np.float64], + signalperiod: int= 9 + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_MFI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_MINUS_DI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_MINUS_DM( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_MOM( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def stream_PLUS_DI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_PLUS_DM( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_PPO( + real: NDArray[np.float64], + fastperiod: int= 12, + slowperiod: int= 26, + matype: MA_Type = MA_Type.SMA + )-> NDArray[np.float64]: ... + +def stream_ROC( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def stream_ROCP( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def stream_ROCR( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def stream_ROCR100( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def stream_RSI( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_STOCH( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + fastk_period: int= 5, + slowk_period: int= 3, + slowk_matype: MA_Type = MA_Type.SMA, + slowd_period: int= 3, + slowd_matype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_STOCHF( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + fastk_period: int= 5, + fastd_period: int= 3, + fastd_matype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_STOCHRSI( + real: NDArray[np.float64], + timeperiod: int= 14, + fastk_period: int= 5, + fastd_period: int= 3, + fastd_matype: MA_Type = MA_Type.SMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_TRIX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_ULTOSC( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod1: int= 7, + timeperiod2: int= 14, + timeperiod3: int= 28 + )-> NDArray[np.float64]: ... + +def stream_WILLR( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +#Volume Indicator Functions + +def stream_AD( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_ADOSC( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64], + fastperiod: int= 3, + slowperiod: int= 10 + )-> NDArray[np.float64]: ... + +def stream_OBV( + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +#Volatility Indicator Functions + +def stream_ATR( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_NATR( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_TRANGE( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +# Price Transform Functions + +def stream_AVGPRICE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_MEDPRICE( + high: NDArray[np.float64], + low: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_TYPPRICE( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_WCLPRICE( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +# Cycle Indicator Functions + +def stream_HT_DCPERIOD(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_HT_DCPHASE(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_HT_PHASOR(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_HT_SINE(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_HT_TRENDMODE(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.int32]]: ... + +#Pattern Recognition Functions + +def stream_CDL2CROWS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDL3BLACKCROWS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDL3INSIDE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDL3LINESTRIKE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDL3OUTSIDE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDL3STARSINSOUTH( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDL3WHITESOLDIERS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLABANDONEDBABY( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def stream_CDLADVANCEBLOCK( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLBELTHOLD( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLBREAKAWAY( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLCLOSINGMARUBOZU( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLCONCEALBABYSWALL( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLCOUNTERATTACK( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLDARKCLOUDCOVER( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def stream_CDLDOJI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLDOJISTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLDRAGONFLYDOJI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLENGULFING( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLEVENINGDOJISTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def stream_CDLEVENINGSTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def stream_CDLGAPSIDESIDEWHITE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLGRAVESTONEDOJI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLHAMMER( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLHANGINGMAN( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLHARAMI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLHARAMICROSS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLHIGHWAVE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLHIKKAKE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLHIKKAKEMOD( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLHOMINGPIGEON( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLIDENTICAL3CROWS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLINNECK( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLINVERTEDHAMMER( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLKICKING( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLKICKINGBYLENGTH( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLLADDERBOTTOM( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLLONGLEGGEDDOJI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLLONGLINE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLMARUBOZU( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLMATCHINGLOW( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLMATHOLD( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def stream_CDLMORNINGDOJISTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def stream_CDLMORNINGSTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + penetration: float= 0 + )-> NDArray[np.int32]: ... + +def stream_CDLONNECK( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLPIERCING( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLRICKSHAWMAN( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLRISEFALL3METHODS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLSEPARATINGLINES( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLSHOOTINGSTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLSHORTLINE( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLSPINNINGTOP( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLSTALLEDPATTERN( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLSTICKSANDWICH( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLTAKURI( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLTASUKIGAP( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLTHRUSTING( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLTRISTAR( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLUNIQUE3RIVER( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLUPSIDEGAP2CROWS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +def stream_CDLXSIDEGAP3METHODS( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.int32]: ... + +# Statistic Functions + +def stream_BETA( + real0: NDArray[np.float64], + real1: NDArray[np.float64], + timeperiod: int= 5 + )-> NDArray[np.float64]: ... + +def stream_CORREL( + real0: NDArray[np.float64], + real1: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_LINEARREG( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_LINEARREG_ANGLE( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_LINEARREG_INTERCEPT( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_LINEARREG_SLOPE( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_STDDEV( + real: NDArray[np.float64], + timeperiod: int= 5, + nbdev: float= 1 + )-> NDArray[np.float64]: ... + +def stream_TSF( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_VAR( + real: NDArray[np.float64], + timeperiod: int= 5, + nbdev: float= 1 + )-> NDArray[np.float64]: ... + +# Math Transform Functions + +def stream_ACOS(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_ASIN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_ATAN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_CEIL(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_COS(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_COSH(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_EXP(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_FLOOR(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_LN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_LOG10(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_SIN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_SINH(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_SQRT(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_TAN(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +def stream_TANH(real: NDArray[np.float64])-> NDArray[np.float64]: ... + +#Math Operator Functions + +def stream_ADD( + real0: NDArray[np.float64], + real1: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_DIV( + real0: NDArray[np.float64], + real1: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_MAX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_MAXINDEX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.int32]: ... + +def stream_MIN( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_MININDEX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.int32]: ... + +def stream_MINMAX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_MINMAXINDEX( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_MULT( + real0: NDArray[np.float64], + real1: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_SUB( + real0: NDArray[np.float64], + real1: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_SUM( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + +def stream_ACCBANDS( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + +def stream_AVGDEV( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_IMI( + open: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... diff --git a/talib/_ta_lib.pyx b/talib/_ta_lib.pyx index c5fdb3748..2b8aec2b6 100644 --- a/talib/_ta_lib.pyx +++ b/talib/_ta_lib.pyx @@ -1,3 +1,5 @@ +#cython: embedsignature=True, emit_code_comments=False + include "_common.pxi" include "_func.pxi" include "_abstract.pxi" diff --git a/talib/py.typed b/talib/py.typed new file mode 100644 index 000000000..e69de29bb 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 ff26785d9..cb1e36ffa 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.4.0' + assert talib.__ta_version__[:5] == b'0.6.4' def test_num_functions(): - assert len(talib.get_functions()) == 158 + assert len(talib.get_functions()) == 161 def test_input_wrong_type(): @@ -164,7 +164,7 @@ def test_RSI(): 0.00000024, 0.00000024, 0.00000023, 0.00000023, 0.00000023], dtype='float64') result = func.RSI(a, 10) - assert_array_equal(result, [np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,0,0,0,0,0,0,0,0,0,0]) + assert_array_almost_equal(result, [np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,33.333333333333329,51.351351351351347,39.491916859122398,51.84807024709005,42.25953803191981,52.101824405061215,52.101824405061215,43.043664867691085,43.043664867691085,43.043664867691085]) result = func.RSI(a * 100000, 10) assert_array_almost_equal(result, [np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,33.333333333333329,51.351351351351347,39.491916859122398,51.84807024709005,42.25953803191981,52.101824405061215,52.101824405061215,43.043664867691085,43.043664867691085,43.043664867691085]) 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 84f9572e2..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.4.0-src.tar.gz" -TA_LIB_URL="http://prdownloads.sourceforge.net/ta-lib/$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 -./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..cc57df507 --- /dev/null +++ b/tools/build_talib_linux.sh @@ -0,0 +1,53 @@ +#!/bin/bash + +TALIB_C_VER="${TALIB_C_VER:=0.6.4}" +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..cc57df507 --- /dev/null +++ b/tools/build_talib_macos.sh @@ -0,0 +1,53 @@ +#!/bin/bash + +TALIB_C_VER="${TALIB_C_VER:=0.6.4}" +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..ad994d948 --- /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.6.4 + +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_func.py b/tools/generate_func.py index 5a625ef08..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 @@ -11,11 +9,27 @@ # FIXME: don't return number of elements since it always equals allocation? functions = [] -include_paths = ['/usr/include', '/usr/local/include', '/opt/include', '/opt/local/include', '/opt/homebrew/include'] if sys.platform == 'win32': - include_paths = [r'c:\ta-lib\c\include'] + include_dirs = [ + r"c:\ta-lib\c\include", + r"c:\Program Files\TA-Lib\include", + r"c:\Program Files (x86)\TA-Lib\include", + ] +else: + include_dirs = [ + '/usr/include', + '/usr/local/include', + '/opt/include', + '/opt/local/include', + '/opt/homebrew/include', + '/opt/homebrew/opt/ta-lib/include', + ] + +if 'TA_INCLUDE_PATH' in os.environ: + include_dirs = os.environ['TA_INCLUDE_PATH'].split(os.pathsep) + header_found = False -for path in include_paths: +for path in include_dirs: ta_func_header = os.path.join(path, 'ta-lib', 'ta_func.h') if os.path.exists(ta_func_header): header_found = True @@ -32,11 +46,11 @@ if tmp or \ line.startswith('TA_RetCode TA_') or \ line.startswith('int TA_'): - line = re.sub('/\*[^\*]+\*/', '', line) # strip comments + line = re.sub(r'/\*[^\*]+\*/', '', line) # strip comments tmp.append(line) if not line: s = ' '.join(tmp) - s = re.sub('\s+', ' ', s) + s = re.sub(r'\s+', ' ', s) functions.append(s) tmp = [] @@ -73,7 +87,7 @@ raise Exception("input array type is not double") if real.ndim != 1: raise Exception("input array has wrong dimensions") - if not (PyArray_FLAGS(real) & np.NPY_C_CONTIGUOUS): + if not (PyArray_FLAGS(real) & np.NPY_ARRAY_C_CONTIGUOUS): real = PyArray_GETCONTIGUOUS(real) return real @@ -173,7 +187,7 @@ cdef: np.ndarray outreal double* outreal_data - outreal = PyArray_EMPTY(1, &length, np.NPY_DOUBLE, np.NPY_DEFAULT) + outreal = PyArray_EMPTY(1, &length, np.NPY_DOUBLE, np.NPY_ARRAY_DEFAULT) outreal_data = outreal.data for i from 0 <= i < min(lookback, length): outreal_data[i] = NaN @@ -183,7 +197,7 @@ cdef: np.ndarray outinteger int* outinteger_data - outinteger = PyArray_EMPTY(1, &length, np.NPY_INT32, np.NPY_DEFAULT) + outinteger = PyArray_EMPTY(1, &length, np.NPY_INT32, np.NPY_ARRAY_DEFAULT) outinteger_data = outinteger.data for i from 0 <= i < min(lookback, length): outinteger_data[i] = 0 @@ -209,12 +223,16 @@ def cleanup(name): i = f.index('(') name = f[:i].split()[1] args = f[i:].split(',') - args = [re.sub('[\(\);]', '', s).strip() for s in args] + args = [re.sub(r'[\(\);]', '', s).strip() for s in args] shortname = name[3:] names.append(shortname) - func_info = abstract.Function(shortname).info - defaults, documentation = abstract._get_defaults_and_docs(func_info) + try: + func_info = abstract.Function(shortname).info + defaults, documentation = abstract._get_defaults_and_docs(func_info) + except: + print("cannot find defaults and docs for", shortname, file=sys.stderr) + defaults, documentation = {}, "" print('@wraparound(False) # turn off relative indexing from end of lists') print('@boundscheck(False) # turn off bounds-checking for entire function') diff --git a/tools/generate_stream.py b/tools/generate_stream.py index fd878ec42..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 @@ -11,11 +9,27 @@ # FIXME: don't return number of elements since it always equals allocation? functions = [] -include_paths = ['/usr/include', '/usr/local/include', '/opt/include', '/opt/local/include', '/opt/homebrew/include'] if sys.platform == 'win32': - include_paths = [r'c:\ta-lib\c\include'] + include_dirs = [ + r"c:\ta-lib\c\include", + r"c:\Program Files\TA-Lib\include", + r"c:\Program Files (x86)\TA-Lib\include", + ] +else: + include_dirs = [ + '/usr/include', + '/usr/local/include', + '/opt/include', + '/opt/local/include', + '/opt/homebrew/include', + '/opt/homebrew/opt/ta-lib/include', + ] + +if 'TA_INCLUDE_PATH' in os.environ: + include_dirs = os.environ['TA_INCLUDE_PATH'].split(os.pathsep) + header_found = False -for path in include_paths: +for path in include_dirs: ta_func_header = os.path.join(path, 'ta-lib', 'ta_func.h') if os.path.exists(ta_func_header): header_found = True @@ -32,11 +46,11 @@ if tmp or \ line.startswith('TA_RetCode TA_') or \ line.startswith('int TA_'): - line = re.sub('/\*[^\*]+\*/', '', line) # strip comments + line = re.sub(r'/\*[^\*]+\*/', '', line) # strip comments tmp.append(line) if not line: s = ' '.join(tmp) - s = re.sub('\s+', ' ', s) + s = re.sub(r'\s+', ' ', s) functions.append(s) tmp = [] @@ -54,8 +68,8 @@ cimport _ta_lib as lib from _ta_lib cimport TA_RetCode # NOTE: _ta_check_success, NaN are defined in common.pxi -# NumPy C API is initialize in _func.pxi +np.import_array() # Initialize the NumPy C API """) # cleanup variable names to make them more pythonic @@ -76,12 +90,16 @@ def cleanup(name): i = f.index('(') name = f[:i].split()[1] args = f[i:].split(',') - args = [re.sub('[\(\);]', '', s).strip() for s in args] + args = [re.sub(r'[\(\);]', '', s).strip() for s in args] shortname = name[3:] names.append(shortname) - func_info = abstract.Function(shortname).info - defaults, documentation = abstract._get_defaults_and_docs(func_info) + try: + func_info = abstract.Function(shortname).info + defaults, documentation = abstract._get_defaults_and_docs(func_info) + except: + print("cannot find defaults and docs for", shortname, file=sys.stderr) + defaults, documentation = {}, "" print('@wraparound(False) # turn off relative indexing from end of lists') print('@boundscheck(False) # turn off bounds-checking for entire function') 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